WoWInterface SVN mNameplates

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /trunk
    from Rev 1 to Rev 2
    ↔ Reverse comparison
  •

Rev 1 → Rev 2

mNameplates/Changelog-mNameplates-r20101026053820.txt New file
0,0 → 1,9
Mange:
- TOC update.
- Fix font flag list for cast bar font selection.
- Added option to change the color of the health percent.
- Added option to override difficulty color on the level text.
- Spell icon added to the CastBar. Text from cast bar is now properly hidden when there is no cast bar
- Add LibBackdrop-1.0 to pkgmeta and Libs/modules.xml
- Added border to the nameplates. Removed debug print in the CastBar module.
- Swtich from SVN to Git
mNameplates/mNameplates.lua New file
0,0 → 1,576
mNameplates = LibStub("AceAddon-3.0"):NewAddon("mNameplates", "AceEvent-3.0", "AceConsole-3.0", "AceHook-3.0")
local mNameplates = mNameplates
MDB_MN = mNameplates
 
mNameplates.DisplayIcon = [[Interface\Icons\inv_shield_09]]
 
local UIF
local LSM = LibStub("LibSharedMedia-3.0")
local AceGUI = LibStub("AceGUI-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
 
LSM:Register("font", "accid", [[Interface\AddOns\mRunes\accid.ttf]])
LSM:Register("statusbar", "HalD", [[Interface\AddOns\mRunes\HalD.tga]])
LSM:Register("border", "Glowing", [[Interface\AddOns\mRunes\Glowing.tga]])
 
local db
 
local Cache = {}
 
local bossIconTexture = [[Interface\TargetingFrame\UI-TargetingFrame-Skull]]
 
local ResetTextures = {
ThreatGlow = [[Interface\TargetingFrame\UI-TargetingFrame-Flash]],
Highlight = [[Interface\Tooltips\Nameplate-Glow]],
BossIcon = [[Interface\TargetingFrame\UI-TargetingFrame-Skull]],
ElitIcon = [[Interface\Tooltips\EliteNameplateIcon]],
CastBorder = [[Interface\Tooltips\Nameplate-Border]],
RaidIcon = [[nterface\TargetingFrame\UI-RaidTargetingIcons]],
}
 
local DefaultWidth, DefaultHeight, DefaultIconSize
local InCombat = false
 
-- Combat Wrappers
local StateScriptSet = {}
local ApplyPlateSet = {}
local PlateReset = {}
 
mNameplates.Levels = {
Bars = 2,
Text = 3,
Icon = 4,
}
 
local StateHeader = CreateFrame("Frame", nil, nil, "SecureHandlerBaseTemplate")
StateHeader:RegisterEvent("PLAYER_REGEN_ENABLED")
StateHeader:SetScript("OnEvent", function(self, event, ...)
for plate in pairs(PlateReset) do
mNameplates:ResetLockedAttributes(plate)
end
wipe(PlateReset)
end)
 
local backdrop = {
tile = true,
tileSize = 16,
insets = {},
}
 
function mNameplates:OnInitialize()
local defaults = {
profile = {
Enabled = true,
 
Width = 125,
Height = 25,
 
BorderWidth = 5,
BorderPadding = 5,
BorderColor = {0, 0, 0, 0.5},
BackgroundColor = {0, 0, 0, 0.5},
BorderInsets = 4,
BorderTexture = "Glowing",
}
}
 
self.db = LibStub("AceDB-3.0"):New("mNameplatesDB", defaults, "Default")
db = self.db.profile
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetupLDB()
 
self:SetEnabledState(db.Enabled)
 
self.Callbacks = LibStub("CallbackHandler-1.0"):New(self)
 
self.Plates = {}
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates", {font = LibStub("LibSharedMedia-3.0"):Fetch("font", "accid"), fontSize = 16})
UIF:SetValuesChangedCallback(function()
mNameplates:ToggleConfig(true)
end)
 
self:RegisterChatCommand("mn", "ToggleConfig")
end
 
function mNameplates:OnEnable()
if UnitAffectingCombat("plater") then InCombat = true end
 
Nameplates.RegisterCallback(self, "LibNameplate_FoundGUID")
Nameplates.RegisterCallback(self, "LibNameplate_NewNameplate")
Nameplates.RegisterCallback(self, "LibNameplate_MouseoverNameplate")
Nameplates.RegisterCallback(self, "LibNameplate_HealthChange")
Nameplates.RegisterCallback(self, "LibNameplate_RecycleNameplate")
 
self:RegisterEvent("UPDATE_MOUSEOVER_UNIT")
self:RegisterEvent("PLAYER_REGEN_DISABLED")
self:RegisterEvent("PLAYER_REGEN_ENABLED")
 
for i, plate in pairs({select(2, Nameplates:GetAllNameplates())}) do
self:LibNameplate_NewNameplate("LibNameplate_NewNameplate", plate)
end
 
wipe(PlateReset)
end
 
function mNameplates:OnDisable()
for moduleName, module in self:IterateModules() do
LibStub("AceAddon-3.0"):DisableAddon(module)
end
for i, plate in pairs(self.Plates) do
plate.DefaultItems.ThreatGlow:SetTexture(ResetTextures.ThreatGlow)
plate.DefaultItems.Highlight:SetTexture(ResetTextures.Highlight)
plate.DefaultItems.BossIcon:SetTexture(ResetTextures.BossIcon)
plate.DefaultItems.ElitIcon:SetTexture(ResetTextures.ElitIcon)
plate.DefaultItems.CastBorder:SetTexture(ResetTextures.CastBorder)
plate.DefaultItems.RaidIcon:SetTexture(ResetTextures.RaidIcon)
plate.DefaultItems.Icon:SetHeight(DefaultIconSize)
plate.DefaultItems.Icon:SetWidth(DefaultIconSize)
 
plate.DefaultItems.Name:Show()
plate.DefaultItems.HealthBorder:Show()
plate.DefaultItems.Level:Show()
plate.DefaultItems.HealthBar:Show()
plate.DefaultItems.CastBar:Show()
 
self:Unhook(plate.DefaultItems.CastBar, "OnShow")
 
 
local data = mNameplates:GetExtra(plate)
data.Background:ClearAllPoints()
data.Background:Hide()
tinsert(Cache, data.Background)
data.Background = nil
 
plate.DefaultItems = nil
plate.mn = nil
 
self:CombatWrapperResetPlate(plate)
end
wipe(self.Plates)
 
Nameplates.UnregisterAllCallbacks(self)
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Callbacks ~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
function mNameplates:LibNameplate_NewNameplate(event, plate)
self:PrepPlate(plate)
plate.DefaultItems.Level:Hide()
 
local filtered = false
for i, filter in pairs(self.Filters) do
local result = filter:RunFilter(plate)
if result then filtered = result end
end
 
local data = mNameplates:GetExtra(plate)
if not filtered then
data.Background:SetParent(plate)
data.Background:Show()
data.Background.backdrop:Show()
self:ApplyOnPlate(plate, data)
 
self.Callbacks:Fire("PlateShow", plate, data)
else
data.Background:SetParent(plate)
data.Background:Show()
data.Background.backdrop:Hide()
self:ApplyOnPlate(plate, data)
 
self.Callbacks:Fire("PlateShowFiltered", plate, data)
end
end
 
function mNameplates:LibNameplate_FoundGUID(event, plate, gUID, unit)
local data = self:GetExtra(plate)
if data then
self.Callbacks:Fire("PlateGUID", gUID, unit, self:GetExtra(plate))
end
end
 
function mNameplates:LibNameplate_MouseoverNameplate(event, plate)
if self.CurrentMouseOver and self.CurrentMouseOver == plate then return end
self:MouseOverUpdate()
self.CurrentMouseOver = plate
local data = mNameplates:GetExtra(plate)
self.Callbacks:Fire("PlateMouseover", plate, data)
self:RegisterOnUpdate(self, self.MouseOverUpdate)
if data then
for i, frame in pairs(data) do
frame:SetFrameLevel(frame:GetFrameLevel() + 100)
end
end
end
 
function mNameplates:LibNameplate_HealthChange(event, plate)
local data = self:GetExtra(plate)
if data then
self.Callbacks:Fire("PlateHPChanged", plate, data)
end
end
 
function mNameplates:LibNameplate_RecycleNameplate(event, plate)
local data = self:GetExtra(plate)
if data then
self.Callbacks:Fire("PlateHide", plate, data)
end
end
 
function mNameplates:ProfileChanged(event)
db = self.db.profile
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Events ~~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
function mNameplates:UPDATE_MOUSEOVER_UNIT(...)
local plate = Nameplates:GetNameplateByUnit("mouseover")
if self.CurrentMouseOver and self.CurrentMouseOver == plate then return end
if plate then
self:MouseOverUpdate()
self.CurrentMouseOver = plate
local data = mNameplates:GetExtra(plate)
self.Callbacks:Fire("PlateMouseover", plate, data)
self:RegisterOnUpdate(self, self.MouseOverUpdate)
if data then
for i, frame in pairs(data) do
frame:SetFrameLevel(frame:GetFrameLevel() + 100)
end
end
end
end
 
function mNameplates:PLAYER_REGEN_DISABLED()
InCombat = true
end
 
function mNameplates:PLAYER_REGEN_ENABLED()
InCombat = false
for plate in pairs(StateScriptSet) do
self:SetStateScript(plate)
end
for plate in pairs(ApplyPlateSet) do
self:SetLockedAttributes(plate)
end
 
 
wipe(StateScriptSet)
wipe(ApplyPlateSet)
wipe(PlateReset)
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Creation ~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
do
local function CastBarShow(self)
self:Hide()
local plate = self:GetParent()
plate.DefaultItems.Icon:SetTexture(nil)
end
 
local regions = {}
function mNameplates:PrepPlate(plate)
if plate.mn then return end
local healthBar, castBar = plate:GetChildren()
local threatGlow, healthBorder, castbarBorder, castNoInterupt, castIcon, highlight, name, level, bossIcon, raidIcon, eliteIcon = plate:GetRegions()
healthBar:Hide()
castBar:Hide()
 
self:HookScript(castBar, "OnShow", CastBarShow)
DefaultIconSize = DefaultIconSize or castIcon:GetHeight()
 
threatGlow:SetTexture(nil)
highlight:SetTexture(nil)
bossIcon:SetTexture(nil)
eliteIcon:SetTexture(nil)
castbarBorder:SetTexture(nil)
castNoInterupt:SetTexture(nil)
raidIcon:SetTexture(nil)
castIcon:SetWidth(0.01)
castIcon:SetHeight(0.01)
 
name:Hide()
healthBorder:Hide()
 
plate.mn = {}
 
plate.DefaultItems = {
HealthBar = healthBar,
CastBar = castBar,
ThreatGlow = threatGlow,
HealthBorder = healthBorder,
CastBorder = castbarBorder,
CastNoInterupt = castNoInterupt,
Icon = castIcon,
Highlight = highlight,
Name = name,
Level = level,
BossIcon = bossIcon,
RaidIcon = raidIcon,
ElitIcon = eliteIcon,
}
 
tinsert(self.Plates, plate)
 
DefaultHeight = DefaultHeight or plate:GetHeight()
DefaultWidth = DefaultWidth or plate:GetWidth()
self:CombatWrapperSetStateScript(plate)
 
local Background = tremove(Cache)
if not Background then
Background = CreateFrame("Frame", nil, plate)
Background:SetFrameLevel(plate:GetFrameLevel())
Background:SetPoint("CENTER")
 
local back = CreateFrame("Frame", nil, Background)
LibStub("LibBackdrop-1.0"):EnhanceBackdrop(back)
back:SetFrameLevel(Background:GetFrameLevel() - 1 )
Background.backdrop = back
end
Background:ClearAllPoints()
Background:SetParent(plate)
Background:SetPoint("CENTER")
plate.mn.Background = Background
 
self.Callbacks:Fire("PlateNew", plate, self:GetExtra(plate))
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Settings ~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
function mNameplates:ApplyOnPlate(plate, data)
self:CombatWrapperApplyPlate(plate)
self:CombatWrapperSetStateScript(plate)
data.Background:SetWidth(db.Width)
data.Background:SetHeight(db.Height)
 
backdrop.insets.left = db.BorderInsets
backdrop.insets.right = db.BorderInsets
backdrop.insets.top = db.BorderInsets
backdrop.insets.bottom = db.BorderInsets
backdrop.edgeFile = LSM:Fetch("border", db.BorderTexture)
 
backdrop.edgeSize = db.BorderWidth
backdrop.bgFile = LSM:Fetch("background", "Solid")
data.Background.backdrop:SetBackdrop(backdrop)
data.Background.backdrop:SetBackdropColor(unpack(db.BackgroundColor))
data.Background.backdrop:SetBackdropBorderColor(unpack(db.BorderColor))
 
data.Background.backdrop:ClearAllPoints()
data.Background.backdrop:SetPoint("TOPLEFT", -db.BorderPadding, db.BorderPadding)
data.Background.backdrop:SetPoint("BOTTOMRIGHT", db.BorderPadding, -db.BorderPadding)
end
 
function mNameplates:Applyettings()
for i, plate in self:IteratePlates() do
self:ApplyOnPlate(plate, self:GetExtra(plate))
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Misc ~~~~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
function mNameplates:IteratePlates()
return pairs(self.Plates)
end
 
function mNameplates:GetExtra(plate)
assert(plate, "No plates passed to get extra")
return plate.mn
end
 
do
local AttachList = {}
local AnchorList = {}
function mNameplates:GetAttachList(callingModule)
wipe(AttachList)
for moduleName, module in self:IterateModules() do
if module ~= callingModule then
AttachList[moduleName] = {text = module.DisplayName or moduleName, value = moduleName, disabled = (not module:IsEnabled()) or (callingModule:GetName() == module.db.profile.AttachedFrame), icon = module.DisplayIcon}
end
end
AttachList["NAMEPLATE"] = {text = "Nameplate", value = "NAMEPLATE", icon = [[Interface\Icons\inv_shield_09]]}
 
return AttachList
end
 
function mNameplates:GetAttachFrame(moduleName, plate)
local module = self:GetModule(moduleName, "true")
if module then
return module:GetAttachFrame(plate)
end
end
 
function mNameplates:GetAnchorList()
AnchorList = AnchorList or {}
AnchorList["TOPLEFT"] = "Top left"
AnchorList["TOP"] = "Top"
AnchorList["TOPRIGHT"] = "Top Right"
AnchorList["RIGHT"] = "Right"
AnchorList["BOTTOMRIGHT"] = "Bottom right"
AnchorList["BOTTOM"] = "Bottom"
AnchorList["BOTTOMLEFT"] = "Bottom left"
AnchorList["LEFT"] = "Left"
AnchorList["CENTER"] = "Center"
 
return AnchorList
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Combat Wrappers ~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
function mNameplates:CombatWrapperSetStateScript(plate)
if InCombat then
StateScriptSet[plate] = true
else
self:SetStateScript(plate)
end
end
 
function mNameplates:CombatWrapperApplyPlate(plate)
if InCombat then
ApplyPlateSet[plate] = true
else
self:SetLockedAttributes(plate)
end
end
 
function mNameplates:CombatWrapperResetPlate(plate)
if InCombat then
PlateReset[plate] = true
else
self:ResetLockedAttributes(plate)
end
end
 
function mNameplates:SetStateScript(plate)
StateHeader:UnwrapScript(plate, "OnShow")
StateHeader:WrapScript(plate, "OnShow", [[
self:SetWidth(]]..db.Width..[[)
self:SetHeight(]]..db.Height..[[)
]])
end
 
function mNameplates:SetLockedAttributes(plate)
plate:SetWidth(db.Width)
plate:SetHeight(db.Height)
end
 
function mNameplates:ResetLockedAttributes(plate)
plate:SetWidth(DefaultWidth)
plate:SetHeight(DefaultHeight)
StateHeader:UnwrapScript(plate, "OnShow")
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Config ~~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
mNameplates:Applyettings()
end
 
local OptionsFrame
local SelectedOption
local OptionsStatus = {}
 
function mNameplates:ToggleConfig(reOpen)
if not OptionsFrame then
OptionsFrame = UIF:Frame("mNameplates")
OptionsFrame:SetLayout("Fill")
OptionsFrame:SetWidth(813)
OptionsFrame:SetHeight(630)
OptionsFrame:Hide()
OptionsFrame:SetCallback("OnClose", function(widget)
OptionsFrame:ReleaseChildren()
OptionsFrame.frame:Hide()
end)
end
 
if OptionsFrame.frame:IsShown() then
OptionsFrame:Hide()
if not reOpen then
return
end
end
 
m = UIF:TreeGroup()
m:SetLayout("Fill")
m:SetCallback("OnGroupSelected", function(self, event, group) SelectedOption = group end)
OptionsFrame:AddChild(m)
 
m:AddGroup({{text = "Main", value = "Main", order = 0}}, function()
local g = UIF:InlineGroup1()
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not mNameplates:IsEnabled() then mNameplates:Enable()
elseif not db.Enabled and mNameplates:IsEnabled() then mNameplates:Disable() end
end))
 
g:AddChild(UIF:Slider("Width", db, "Width", 0, 300, 0.1, Callback, 0.5))
g:AddChild(UIF:Slider("Height", db, "Height", 0, 300, 0.1, Callback, 0.5))
 
 
local g2 = UIF:InlineGroup1("Border and Color")
 
g2:AddChild(UIF:ColorSelect("Border Color", db, "BorderColor", Callback, true, 0.5))
g2:AddChild(UIF:ColorSelect("Background Color", db, "BackgroundColor", Callback, true, 0.5))
 
g2:AddChild(UIF:LSMDropdown("border", "Border texture", db, "BorderTexture", Callback, 0.5))
g2:AddChild(UIF:Slider("Border Width", db, "BorderWidth", 0, 50, 0.1, Callback, 0.5))
g2:AddChild(UIF:Slider("Padding", db, "BorderPadding", 0, 50, 0.1, Callback, 0.5))
g2:AddChild(UIF:Slider("Insets", db, "BorderInsets", 0, 50, 0.1, Callback, 0.5))
 
return g, g2
end, self.DisplayIcon)
 
for moduleName, module in self:IterateModules() do
if module.GetOptions then
local options = module:GetOptions()
if options and type(options) == "table" then
for i, option in pairs(options) do
m:AddGroup(option.data, option.func, option.icon)
end
end
end
end
 
m:AddGroup({{text = "Profile", value = "Profile"}}, function()
return UIF:AceProfileOption(mNameplates.db)
end)
 
m:SetSelected(SelectedOption or "Main")
m:SetStatusTable(OptionsStatus)
OptionsFrame:Show()
end
 
function mNameplates:SetupLDB()
local LDB = LibStub("LibDataBroker-1.1")
if not LDB then return end
 
local l = LDB:NewDataObject("mNameplates")
l.type = "launcher"
l.icon = [[Interface\Icons\Spell_DeathKnight_RuneTap]]
l.tocname = "mNameplates"
l.label = "mNameplates"
l.OnClick = function(self, button)
mNameplates:ToggleConfig()
end
l.OnTooltipShow = function(tt)
tt:AddLine("mNameplates")
tt:AddLine("Click to toggle configuration")
end
 
self.ldbojb = l
end
end
\ No newline at end of file
mNameplates/Filters/Prototype.lua New file
0,0 → 1,31
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
mNameplates.Filters = mNameplates.Filters or {}
 
local FilterModuleProt = {}
 
function mNameplates:NewFilterModule(moduleName, ...)
local filter = self:NewModule(moduleName, FilterModuleProt, ...)
tinsert(self.Filters, filter)
return filter
end
 
function mNameplates:FilterChanged()
for i, plate in self:IteratePlates() do
self:LibNameplate_RecycleNameplate("LibNameplate_RecycleNameplate", plate)
self:LibNameplate_NewNameplate("LibNameplate_NewNameplate", plate)
end
end
 
function FilterModuleProt:OnInitialize()
end
 
function FilterModuleProt:OnEnable()
end
 
function FilterModuleProt:OnDisable()
end
 
function FilterModuleProt:RunFilter()
error(self:GetName().." does not supply a RunFilter(plate) function")
end
\ No newline at end of file
mNameplates/Filters/NameFilter.lua New file
0,0 → 1,184
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
 
local plugin = mNameplates:NewFilterModule("NameFilter")
plugin.DisplayName = "Name Filter"
 
local AceGUI = LibStub("AceGUI-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
local UIF
local db
 
 
local defaults = {
profile = {
Enabled = true,
 
Categories = {
["**"] = {
Enabled = true,
Names = {
},
},
Default = {
}
}
}
}
 
function plugin:OnInitialize()
self.db = mNameplates.db:RegisterNamespace(self:GetName(), defaults)
db = self.db.profile
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetEnabledState(db.Enabled)
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates")
end
 
function plugin:OnEnable()
end
 
function plugin:OnDisable()
end
 
function plugin:ProfileChanged(event)
db = self.db.profile
if db.Enabled then
if not self:IsEnabled() then self:Enable() end
elseif not db.Enabled and self:IsEnabled() then
self:Disable()
end
end
 
-- ~~~~~~~~~~~~~~~~~~
-- Filter ~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~
function plugin:RunFilter(plate)
if not self:IsEnabled() then return end
 
local plateName = Nameplates:GetName(plate)
 
for categoryName, category in pairs(db.Categories) do
if category.Enabled then
for name, enabled in pairs(category.Names) do
if plateName == name and enabled then
return true
end
end
end
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Options ~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
mNameplates:FilterChanged()
end
 
local NameList = {}
local function GetNameList(category)
wipe(NameList)
for name in pairs(category.Names) do
NameList[name] = name
end
return NameList
end
 
local CategoryList = {}
local function GetCategoryList()
wipe(CategoryList)
for categoryName in pairs(db.Categories) do
CategoryList[categoryName] = categoryName
end
return CategoryList
end
 
local function DeleteNameCallback(widget, event, name)
db.Names[name] = nil
Callback()
mNameplates:ToggleConfig(true)
end
 
local options
function plugin:GetOptions()
if options then return options end
options = {
{
data = {{text = plugin.DisplayName, value = plugin.DisplayName}},
func = function()
local g = AceGUI:Create("SimpleGroup")
g:SetLayout("Flow")
g:SetFullWidth(true)
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not plugin:IsEnabled() then plugin:Enable()
elseif not db.Enabled and plugin:IsEnabled() then plugin:Disable() end
end))
 
local ed = AceGUI:Create("EditBox")
ed:SetLabel("Add New Category")
ed:SetCallback("OnEnterPressed", function(self, event, text)
self.editbox:ClearFocus()
local t = db.Categories[text]
mNameplates:ToggleConfig(true)
end)
ed:SetRelativeWidth(0.4)
g:AddChild(ed)
 
g:AddChild(UIF:SimpleDropdown("Delete Category", function(widget, event, category)
db.Categories[category] = nil
Callback()
mNameplates:ToggleConfig(true)
end, GetCategoryList(), 0.4))
 
for categoryName, category in pairs(db.Categories) do
local group = UIF:InlineGroup1(categoryName)
g:AddChild(group)
 
group:AddChild(UIF:CheckBox("Enabled", category, "Enabled", Callback))
 
local ed = AceGUI:Create("EditBox")
ed:SetLabel("Add Name")
ed:SetCallback("OnEnterPressed", function(self, event, text)
self.editbox:ClearFocus()
category.Names[text] = true
Callback()
mNameplates:ToggleConfig(true)
end)
ed:SetRelativeWidth(0.4)
group:AddChild(ed)
 
group:AddChild(UIF:SimpleDropdown("Delete name", function(widget, event, name)
category.Names[name] = nil
Callback()
mNameplates:ToggleConfig(true)
end, GetNameList(category), 0.4))
group:AddChild(UIF:Button("Add target", function()
local name = UnitName("target")
if not name then return end
category.Names[name] = true
Callback()
mNameplates:ToggleConfig(true)
end))
 
group:AddChild(UIF:NewLine())
for name in pairs(category.Names) do
group:AddChild(UIF:CheckBox(name, category.Names, name, Callback, nil, 0.25))
end
end
 
 
 
return g
end
}
}
return options
end
end
\ No newline at end of file
mNameplates/Filters/TypeFilter.lua
mNameplates/Libs/AceEvent-3.0/AceEvent-3.0.xml New file
0,0 → 1,4
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Script file="AceEvent-3.0.lua"/>
</Ui>
\ No newline at end of file
mNameplates/Libs/AceEvent-3.0/AceEvent-3.0.lua New file
0,0 → 1,126
--- AceEvent-3.0 provides event registration and secure dispatching.
-- All dispatching is done using **CallbackHandler-1.0**. AceEvent is a simple wrapper around
-- CallbackHandler, and dispatches all game events or addon message to the registrees.
--
-- **AceEvent-3.0** can be embeded into your addon, either explicitly by calling AceEvent:Embed(MyAddon) or by
-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object
-- and can be accessed directly, without having to explicitly call AceEvent itself.\\
-- It is recommended to embed AceEvent, otherwise you'll have to specify a custom `self` on all calls you
-- make into AceEvent.
-- @class file
-- @name AceEvent-3.0
-- @release $Id: AceEvent-3.0.lua 975 2010-10-23 11:26:18Z nevcairiel $
local MAJOR, MINOR = "AceEvent-3.0", 3
local AceEvent = LibStub:NewLibrary(MAJOR, MINOR)
 
if not AceEvent then return end
 
-- Lua APIs
local pairs = pairs
 
local CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0")
 
AceEvent.frame = AceEvent.frame or CreateFrame("Frame", "AceEvent30Frame") -- our event frame
AceEvent.embeds = AceEvent.embeds or {} -- what objects embed this lib
 
-- APIs and registry for blizzard events, using CallbackHandler lib
if not AceEvent.events then
AceEvent.events = CallbackHandler:New(AceEvent,
"RegisterEvent", "UnregisterEvent", "UnregisterAllEvents")
end
 
function AceEvent.events:OnUsed(target, eventname)
AceEvent.frame:RegisterEvent(eventname)
end
 
function AceEvent.events:OnUnused(target, eventname)
AceEvent.frame:UnregisterEvent(eventname)
end
 
 
-- APIs and registry for IPC messages, using CallbackHandler lib
if not AceEvent.messages then
AceEvent.messages = CallbackHandler:New(AceEvent,
"RegisterMessage", "UnregisterMessage", "UnregisterAllMessages"
)
AceEvent.SendMessage = AceEvent.messages.Fire
end
 
--- embedding and embed handling
local mixins = {
"RegisterEvent", "UnregisterEvent",
"RegisterMessage", "UnregisterMessage",
"SendMessage",
"UnregisterAllEvents", "UnregisterAllMessages",
}
 
--- Register for a Blizzard Event.
-- The callback will be called with the optional `arg` as the first argument (if supplied), and the event name as the second (or first, if no arg was supplied)
-- Any arguments to the event will be passed on after that.
-- @name AceEvent:RegisterEvent
-- @class function
-- @paramsig event[, callback [, arg]]
-- @param event The event to register for
-- @param callback The callback function to call when the event is triggered (funcref or method, defaults to a method with the event name)
-- @param arg An optional argument to pass to the callback function
 
--- Unregister an event.
-- @name AceEvent:UnregisterEvent
-- @class function
-- @paramsig event
-- @param event The event to unregister
 
--- Register for a custom AceEvent-internal message.
-- The callback will be called with the optional `arg` as the first argument (if supplied), and the event name as the second (or first, if no arg was supplied)
-- Any arguments to the event will be passed on after that.
-- @name AceEvent:RegisterMessage
-- @class function
-- @paramsig message[, callback [, arg]]
-- @param message The message to register for
-- @param callback The callback function to call when the message is triggered (funcref or method, defaults to a method with the event name)
-- @param arg An optional argument to pass to the callback function
 
--- Unregister a message
-- @name AceEvent:UnregisterMessage
-- @class function
-- @paramsig message
-- @param message The message to unregister
 
--- Send a message over the AceEvent-3.0 internal message system to other addons registered for this message.
-- @name AceEvent:SendMessage
-- @class function
-- @paramsig message, ...
-- @param message The message to send
-- @param ... Any arguments to the message
 
 
-- Embeds AceEvent into the target object making the functions from the mixins list available on target:..
-- @param target target object to embed AceEvent in
function AceEvent:Embed(target)
for k, v in pairs(mixins) do
target[v] = self[v]
end
self.embeds[target] = true
return target
end
 
-- AceEvent:OnEmbedDisable( target )
-- target (object) - target object that is being disabled
--
-- Unregister all events messages etc when the target disables.
-- this method should be called by the target manually or by an addon framework
function AceEvent:OnEmbedDisable(target)
target:UnregisterAllEvents()
target:UnregisterAllMessages()
end
 
-- Script to fire blizzard events into the event listeners
local events = AceEvent.events
AceEvent.frame:SetScript("OnEvent", function(this, event, ...)
events:Fire(event, ...)
end)
 
--- Finally: upgrade our old embeds
for target, v in pairs(AceEvent.embeds) do
AceEvent:Embed(target)
end
mNameplates/Libs/LibBackdrop-1.0/LibBackdrop-1.0.toc New file
0,0 → 1,15
## Interface: 40000
## X-Compatible-With: 30300
## Title: Lib: Backdrop-1.0
## Notes: Dropin replacement library for SetBackDrop
## Author: kagaro, lilsparky
## X-Website: http://www.wowace.com
## X-Category: Library
## X-License: All Rights Reserved
## X-Curse-Packaged-Version: 1.0.7
## X-Curse-Project-Name: LibBackdrop-1.0
## X-Curse-Project-ID: libbackdrop-1-0
## X-Curse-Repository-ID: wow/libbackdrop-1-0/mainline
 
LibStub\LibStub.lua
LibBackdrop-1.0.lua
\ No newline at end of file
mNameplates/Libs/LibBackdrop-1.0/LibBackdrop-1.0.lua New file
0,0 → 1,514
--[[
Replacement library for SetBackDrop
Blizzard decided they want to deprecate SetBackDrop, so this library is intended as a replacement for simple table drop
and decorate a given frame with a backdrop.
Credits to Lilsparky for doing the math for cutting up the quadrants
--]]
local MAJOR, MINOR = "LibBackdrop-1.0", 1
local Backdrop, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
 
if not Backdrop then return end -- No upgrade needed
 
local MakeFrame = CreateFrame
 
local edgePoints = {
TOPLEFTCORNER = "TOPLEFT",
TOP = "TOP",
TOPRIGHTCORNER = "TOPRIGHT",
LEFT = "LEFT",
RIGHT = "RIGHT",
BOTLEFTCORNER = "BOTTOMLEFT",
BOT = "BOTTOM",
BOTRIGHTCORNER = "BOTTOMRIGHT"
}
 
function Backdrop:Embed(frame)
print("Embed is now deprecated, use :EnhanceBackdrop instead")
self:EnhanceBackdrop(frame)
end
 
--- API
-- This method will embed the new backdrop functionality onto your frame
-- This will replace the standard SetBackdropxxx functions and will add
-- the following functions to your frame.
-- SetBackdropGradient(orientation,minR,minG,minB,maxR,maxG,maxB) setup a gradient on the bg texture
-- SetBackdropGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA) setup a gradient on the bg texture
-- SetBackdropBorderGradient(orientation,minR,minG,minB,maxR,maxG,maxB) setup a gradient on the border texture
-- SetBackdropBorderGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA) setup a gradient on the border texture
-- @param frame to enhance
 
function Backdrop:EnhanceBackdrop(frame)
if frame._backdrop then return end
-- Create our enhancement frame we will use to create the backdrop
frame._backdrop = MakeFrame("Frame",nil,frame)
for k,v in pairs(edgePoints) do
local texture = frame:CreateTexture(nil,"BORDER")
frame._backdrop["Edge"..k] = texture
end
frame._backdrop["bgTexture"] = frame:CreateTexture(nil,"BACKGROUND")
frame.SetBackdrop = Backdrop.SetBackdrop -- Set the backdrop of the frame according to the specification provided.
frame.GetBackdrop = Backdrop.GetBackdrop -- Get the backdrop of the frame for use in SetBackdrop
frame.SetBackdropBorderColor = Backdrop.SetBackdropBorderColor --(r, g, b[, a]) - Set the frame's backdrop's border's color.
frame.GetBackdropBorderColor = Backdrop.GetBackdropBorderColor -- Get the frame's backdrop's border's color.
frame.SetBackdropColor = Backdrop.SetBackdropColor --(r, g, b[, a]) - Set the frame's backdrop color.
frame.GetBackdropColor = Backdrop.GetBackdropColor -- Get the backdrop color
frame.SetBackdropGradient = Backdrop.SetBackdropGradient -- New API
frame.SetBackdropGradientAlpha = Backdrop.SetBackdropGradientAlpha -- New API
frame.SetBackdropBorderGradient = Backdrop.SetBackdropBorderGradient -- New API
frame.SetBackdropBorderGradientAlpha = Backdrop.SetBackdropBorderGradientAlpha -- New API
frame.GetBackdropBorderSection = Backdrop.GetBackdropBorderSection -- New API
frame.GetBackdropBackground = Backdrop.GetBackdropBackground -- New API
frame.BorderTextureFunction = Backdrop.BorderTextureFunction
end
 
--- API
-- this method will let you test to see if a frame has been embedded with enchanced backdrop
-- @param frame to check
-- @return true if embedded already
function Backdrop:IsEmbedded(frame)
print("IsEmbedded is now deprecate use :IsEnhanced")
return self:IsEnhanced(frame)
end
 
function Backdrop:IsEnhanced(frame)
return frame._backdrop ~= nil
end
 
--- API
-- Convience method to mass execute a given function and params across
-- all border segments
function Backdrop:BorderTextureFunction(func,...)
-- check to see the function exists for a texture object
if not self._backdrop.bgTexture[func] then return end
for k,v in pairs(edgePoints) do
local texture = self._backdrop["Edge"..k]
texture[func](texture,...)
end
end
 
--- API
-- This method allows you to get a reference to the backdrop itself
-- @return a reference to the backdrop background texture
function Backdrop:GetBackdropBackground()
return self._backdrop["bgTexture"]
end
--- API
-- this method allows you to get a reference to given border section
-- @param section [Valid values are: TOPLEFTCORNER,TOP,TOPRIGHTCORNER,LEFT,RIGHT,BOTLEFTCORNER,BOT,BOTRIGHTCORNER]
-- @return the section texture or nil
function Backdrop:GetBackdropBorderSection(section)
section = strupper(section)
return self._backdrop["Edge"..section]
end
 
 
--[[
FUTURE, once blizz removes SetBackdrop, we should hook CreateFrame and automatically embed ourselves
to allow for backwards compat
--]]
 
--[[
{
bgFile = "bgFile",
edgeFile = "edgeFile", tile = false, tileSize = 0, edgeSize = 32,
insets = { left = 0, right = 0, top = 0, bottom = 0
}
Alternatily you can use the new blizz style of borders
where you have a corner file and 1 file for each side. To build those style of borders
be sure each quadrant is 32x32 blocks. See Interface\DialogFrame\DialogFrame-Corners and Interface\DialogFrame\DialogFrame-Top
for examples. To pass those style borders in, setup the edge file as follows
edgeFile = {
["TOPLEFTCORNER"] = "Interface/DialogFrame/DialogFrame-Corners",
["TOPRIGHTCORNER"] = "Interface/DialogFrame/DialogFrame-Corners",
["BOTLEFTCORNER"] = "Interface/DialogFrame/DialogFrame-Corners",
["BOTRIGHTCORNER"] = "Interface/DialogFrame/DialogFrame-Corners",
["LEFT"] = "Interface/DialogFrame/DialogFrame-Left",
["TOP"] = "Interface/DialogFrame/DialogFrame-Top",
["BOT"] = "Interface/DialogFrame/DialogFrame-Bot",
["RIGHT"] = "Interface/DialogFrame/DialogFrame-Right",
}
--]]
 
local tilingOptions = {
["LEFT"] = true,
["RIGHT"] = true,
["TOP"] = true,
["BOTTOM"] = true,
["TOPLEFTCORNER"] = false,
["TOPRIGHTCORNER"] = false,
["BOTLEFTCORNER"] = false,
["BOTRIGHTCORNER"] = false,
}
 
-- Corners and their quadrant positions
local corners = {
TOPLEFTCORNER = 4,
TOPRIGHTCORNER = 5,
BOTLEFTCORNER = 6,
BOTRIGHTCORNER = 7,
}
-- Sides and their quadrant positions
local vSides = {
LEFT = 0,
RIGHT = 1,
}
local hSides = {
TOP = 2,
BOT = 3,
}
 
-- Resizing hook to keep them aligned
local function Resize(frame)
if not frame then
return
end
local w,h = frame:GetWidth()-frame.bgEdgeSize*2, frame:GetHeight()-frame.bgEdgeSize*2
for k,v in pairs(vSides) do
local t = frame["Edge"..k]
local y = h/frame.bgEdgeSize
t:SetTexCoord(v*.125, v*.125+.125, 0, y)
end
for k,v in pairs(hSides) do
local t = frame["Edge"..k]
local y = w/frame.bgEdgeSize
local x1 = v*.125
local x2 = v*.125+.125
t:SetTexCoord(x1,0, x2,0, x1,y, x2, y)
end
if frame.tile then
frame.bgTexture:SetTexCoord(0,w/frame.tileSize, 0,h/frame.tileSize)
end
end
 
-- Attach the corner textures
local function AttachCorners(frame,options)
local nudge = 0
if options.edgeSize >= 32 then
nudge = options.edgeSize/32
end
if options.edgeSize <= 16 then
nudge = options.edgeSize/16
end
for k,v in pairs(corners) do
local texture = frame["Edge"..k]
texture:ClearAllPoints()
texture:SetWidth(options.edgeSize)
texture:SetHeight(options.edgeSize)
texture:SetTexCoord(v*.125,v*.125+.125, 0,1)
end
frame["EdgeTOPLEFTCORNER"]:SetPoint(edgePoints["TOPLEFTCORNER"],frame,0,nudge)
frame["EdgeBOTLEFTCORNER"]:SetPoint(edgePoints["BOTLEFTCORNER"],frame,0,-nudge)
frame["EdgeTOPRIGHTCORNER"]:SetPoint(edgePoints["TOPRIGHTCORNER"],frame,0,nudge)
frame["EdgeBOTRIGHTCORNER"]:SetPoint(edgePoints["BOTRIGHTCORNER"],frame,0,-nudge)
 
end
local nk = {
["TOPLEFTCORNER"] = { l = 0, r = 0.5, t= 0, b=0.5},
["TOPRIGHTCORNER"] = { l = 0.5, r = 1, t= 0, b=0.5},
["BOTLEFTCORNER"] = { l = 0, r = 0.5, t= 0.5, b=1},
["BOTRIGHTCORNER"] = { l = 0.5, r = 1, t= 0.5, b=1},
}
-- Attach new style corners
local function AttachNewCorners(frame)
for k,v in pairs(corners) do
local texture = frame["Edge"..k]
texture:SetPoint(edgePoints[k], frame)
texture:SetWidth(frame.bgEdgeSize)
texture:SetHeight(frame.bgEdgeSize)
texture:SetTexCoord(nk[k].l,nk[k].r,nk[k].t,nk[k].b)
end
end
-- Attach new style sdes
local function AttachNewSides(frame,w,h)
local offset = 1
offset = frame.bgEdgeSize /32
-- Left and Right
frame["EdgeLEFT"]:SetPoint("TOPLEFT",frame["EdgeTOPLEFTCORNER"],"BOTTOMLEFT",offset,0)
frame["EdgeLEFT"]:SetPoint("BOTTOMLEFT",frame["EdgeBOTLEFTCORNER"],"TOPLEFT",offset,0)
frame["EdgeLEFT"]:SetWidth(frame.bgEdgeSize/2)
frame["EdgeLEFT"]:SetVertTile(true)
frame["EdgeLEFT"]:SetHorizTile(false)
frame["EdgeRIGHT"]:SetPoint("TOPRIGHT",frame["EdgeTOPRIGHTCORNER"],"BOTTOMRIGHT")
frame["EdgeRIGHT"]:SetPoint("BOTTOMRIGHT",frame["EdgeBOTRIGHTCORNER"],"TOPRIGHT")
frame["EdgeRIGHT"]:SetWidth(frame.bgEdgeSize/2)
frame["EdgeRIGHT"]:SetVertTile(true)
frame["EdgeRIGHT"]:SetHorizTile(false)
-- Top and Bottom
frame["EdgeTOP"]:SetPoint("TOPLEFT",frame["EdgeTOPLEFTCORNER"],"TOPRIGHT",0,-offset)
frame["EdgeTOP"]:SetPoint("TOPRIGHT",frame["EdgeTOPRIGHTCORNER"],"TOPLEFT",0,-offset)
frame["EdgeTOP"]:SetHeight(frame.bgEdgeSize/2)
frame["EdgeTOP"]:SetVertTile(false)
frame["EdgeTOP"]:SetHorizTile(true)
frame["EdgeBOT"]:SetPoint("BOTTOMLEFT",frame["EdgeBOTLEFTCORNER"],"BOTTOMRIGHT")
frame["EdgeBOT"]:SetPoint("BOTTOMRIGHT",frame["EdgeBOTRIGHTCORNER"],"BOTTOMLEFT")
frame["EdgeBOT"]:SetHeight(frame.bgEdgeSize/2)
frame["EdgeBOT"]:SetVertTile(false)
frame["EdgeBOT"]:SetHorizTile(true)
end
-- Attach the side textures
local function AttachSides(frame,w,h,options)
local nudge = 0.125
if options.edgeSize >= 32 then
nudge = nudge * (options.edgeSize/32)
end
if options.edgeSize <= 16 then
nudge = nudge / (16/options.edgeSize)
end
local offset = 0
if options.edgeSize >= 32 then
offset = options.edgeSize/32
end
if options.edgeSize <= 16 then
offset = options.edgeSize/16
end
-- SOOOO Issue here is when resetting an existing border the top area gets jacked up
-- Left and Right
for k,v in pairs(vSides) do
local texture = frame["Edge"..k]
texture:ClearAllPoints()
if k == "RIGHT" then
texture:SetPoint(edgePoints[k], frame, nudge,0)
texture:SetPoint("BOTTOM", frame, "BOTTOM", 0, options.edgeSize-offset)
texture:SetPoint("TOP", frame, "TOP", 0, -options.edgeSize+offset)
else
texture:SetPoint(edgePoints[k], frame, nudge,0)
texture:SetPoint("BOTTOM", frame, "BOTTOM", 0, options.edgeSize-offset)
texture:SetPoint("TOP", frame, "TOP", 0, -options.edgeSize+offset)
end
texture:SetWidth(options.edgeSize)
local y = h/options.edgeSize
texture:SetTexCoord(v*.125, v*.125+.125, 0, y)
end
-- Top and Bottom
for k,v in pairs(hSides) do
local texture = frame["Edge"..k]
texture:ClearAllPoints()
-- Adjusments for placement
if k == "TOP" then
texture:SetPoint(edgePoints[k], frame, nudge, offset)
texture:SetPoint("LEFT", frame, "LEFT", options.edgeSize, 0)
texture:SetPoint("RIGHT", frame, "RIGHT", -options.edgeSize, 0)
else
texture:SetPoint(edgePoints[k], frame,-nudge,-offset)
texture:SetPoint("LEFT", frame, "LEFT", options.edgeSize, 1)
texture:SetPoint("RIGHT", frame, "RIGHT", -options.edgeSize, 1)
end
texture:SetHeight(options.edgeSize)
local y = w/options.edgeSize
local x1 = v*.125
local x2 = v*.125+.125
if k == "TOP" then -- Flip
x1,x2 = x2, x1
end
texture:SetTexCoord(x1,0, x2,0, x1,y, x2, y)
end
end
 
--- API
-- Setup the backdrop see normal wow api for table options
function Backdrop:SetBackdrop(options)
if not options then return end
-- Set textures
local vTile = false
local hTile = false
if options.tile then
hTile = true
end
local reset = false
if self._backdrop_options then
table.wipe(self._backdrop_options)
reset = true
else
self._backdrop_options = {}
end
-- Copy backdrop options
self._backdrop_options.bgFile = options.bgFile
self._backdrop_options.edgeFile = options.edgeFile
self._backdrop_options.tile = options.tile
self._backdrop_options.tileSize = options.tileSize
self._backdrop_options.edgeSize = options.edgeSize
self._backdrop_options.insets = {}
self._backdrop_options.insets.left = options.insets.left
self._backdrop_options.insets.right = options.insets.right
self._backdrop_options.insets.top = options.insets.top
self._backdrop_options.insets.bottom = options.insets.bottom
if type(options.edgeFile) == "table" then
Backdrop.SetNewBackdrop(self,options)
else
self._backdrop["bgTexture"]:SetTexture(options.bgFile,hTile,vTile)
for k,v in pairs(edgePoints) do
self._backdrop["Edge"..k]:SetTexture(options.edgeFile,tilingOptions[k])
end
-- Copy options
self._backdrop.tileSize = options.tileSize
self._backdrop.tile = options.tile
self._backdrop.bgEdgeSize = options.edgeSize
-- Setup insets
self._backdrop:ClearAllPoints()
self._backdrop:SetAllPoints(self)
local w,h = self:GetWidth()-(options.edgeSize*2), self:GetHeight()-(options.edgeSize*2)
if options.edgeSize > 0 then
-- Attach croners
AttachCorners(self._backdrop, self._backdrop_options)
-- Attach sides
AttachSides(self._backdrop,w,h, self._backdrop_options)
end
-- Attach Background
self._backdrop.bgTexture:ClearAllPoints()
self._backdrop.bgTexture:SetPoint("TOPLEFT", self._backdrop, "TOPLEFT", options.insets.left, -options.insets.top)
self._backdrop.bgTexture:SetPoint("BOTTOMRIGHT", self._backdrop, "BOTTOMRIGHT", -options.insets.right, options.insets.bottom)
if options.tile then
self._backdrop.bgTexture:SetTexCoord(0,w/options.tileSize, 0,h/options.tileSize)
end
self._backdrop:SetScript("OnSizeChanged", Resize)
end
if reset then
Resize(self._backdrop)
end
end
 
-- replace std api call
function Backdrop:GetBackdrop()
return self._backdrop_options
end
 
-- replace std api call
function Backdrop:GetBackdropColor()
return self._backdrop.bgTexture:GetVertexColor()
end
 
-- repalce std api call
function Backdrop:GetBackdropBorderColor()
return self._backdrop["EdgeTOP"]:GetVertexColor()
end
 
--- API
-- change the backdrop border color
-- @params r,g,b[,a]
function Backdrop:SetBackdropBorderColor(...)
for k,v in pairs(edgePoints) do
self._backdrop["Edge"..k]:SetVertexColor(...)
end
end
--- API
-- set the backdrop color
-- @params r,g,b[,a]
function Backdrop:SetBackdropColor(...)
self._backdrop["bgTexture"]:SetVertexColor(...)
end
 
--- API
-- set the backdrop gradient color
-- @params "orientation", minR, minG, minB, maxR, maxG, maxB
function Backdrop:SetBackdropGradient(...)
self._backdrop["bgTexture"]:SetGradient(...)
end
 
--- API
-- set the backdrop gradient with alpha
-- @params "orientation", minR, minG, minB, minA, maxR, maxG, maxB, maxA
function Backdrop:SetBackdropGradientAlpha(...)
self._backdrop["bgTexture"]:SetGradientAlpha(...)
end
 
--- API
-- set the border gradient color
-- @params "orientation", minR, minG, minB, maxR, maxG, maxB
function Backdrop:SetBackdropBorderGradient(orientation,minR,minG,minB,maxR,maxG,maxB)
orientation = strupper(orientation)
if orientation == "HORIZONTAL" then
self._backdrop["EdgeTOPLEFTCORNER"]:SetGradient(orientation,minR,minG,minB,minR,minG,minB)
self._backdrop["EdgeBOTLEFTCORNER"]:SetGradient(orientation,minR,minG,minB,minR,minG,minB)
self._backdrop["EdgeLEFT"]:SetGradient(orientation,minR,minG,minB,minR,minG,minB)
self._backdrop["EdgeBOT"]:SetGradient(orientation,minR,minG,minB,maxR,maxG,maxB)
self._backdrop["EdgeTOP"]:SetGradient(orientation,minR,minG,minB,maxR,maxG,maxB)
self._backdrop["EdgeTOPRIGHTCORNER"]:SetGradient(orientation,maxR,maxG,maxB,maxR,maxG,maxB)
self._backdrop["EdgeBOTRIGHTCORNER"]:SetGradient(orientation,maxR,maxG,maxB,maxR,maxG,maxB)
self._backdrop["EdgeRIGHT"]:SetGradient(orientation,maxR,maxG,maxB,maxR,maxG,maxB)
else
self._backdrop["EdgeTOPLEFTCORNER"]:SetGradient(orientation,maxR,maxG,maxB,maxR,maxG,maxB)
self._backdrop["EdgeBOTLEFTCORNER"]:SetGradient(orientation,minR,minG,minB,minR,minG,minB)
self._backdrop["EdgeLEFT"]:SetGradient(orientation,minR,minG,minB,maxR,maxG,maxB)
self._backdrop["EdgeBOT"]:SetGradient(orientation,minR,minG,minB,minR,minG,minB)
self._backdrop["EdgeTOP"]:SetGradient(orientation,maxR,maxG,maxB,maxR,maxG,maxB)
self._backdrop["EdgeTOPRIGHTCORNER"]:SetGradient(orientation,maxR,maxG,maxB,maxR,maxG,maxB)
self._backdrop["EdgeBOTRIGHTCORNER"]:SetGradient(orientation,minR,minG,minB,minR,minG,minB)
self._backdrop["EdgeRIGHT"]:SetGradient(orientation,minR,minG,minB,maxR,maxG,maxB)
end
end
 
--- API
-- set the border gradient alpha color
-- @params "orientation", minR, minG, minB, minA, maxR, maxG, maxB, maxA
function Backdrop:SetBackdropBorderGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA)
orientation = strupper(orientation)
if orientation == "HORIZONTAL" then
self._backdrop["EdgeTOPLEFTCORNER"]:SetGradientAlpa(orientation,minR,minG,minB,minA,minR,minG,minB,minA)
self._backdrop["EdgeBOTLEFTCORNER"]:SetGradientAlpha(orientation,minR,minG,minB,minA,minR,minG,minB,minA)
self._backdrop["EdgeLEFT"]:SetGradientAlpha(orientation,minR,minG,minB,minA,minR,minG,minB,minA)
self._backdrop["EdgeBOT"]:SetGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA)
self._backdrop["EdgeTOP"]:SetGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA)
self._backdrop["EdgeTOPRIGHTCORNER"]:SetGradientAlpha(orientation,maxR,maxG,maxB,maxA,maxR,maxG,maxB,maxA)
self._backdrop["EdgeBOTRIGHTCORNER"]:SetGradientAlpha(orientation,maxR,maxG,maxB,maxA,maxR,maxG,maxB,maxA)
self._backdrop["EdgeRIGHT"]:SetGradientAlpha(orientation,maxR,maxG,maxB,maxA,maxR,maxG,maxB,maxA)
else
self._backdrop["EdgeTOPLEFTCORNER"]:SetGradientAlpha(orientation,maxR,maxG,maxB,maxA,maxR,maxG,maxB,maxA)
self._backdrop["EdgeBOTLEFTCORNER"]:SetGradientAlpha(orientation,minR,minG,minB,minA,minR,minG,minB,minA)
self._backdrop["EdgeLEFT"]:SetGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA)
self._backdrop["EdgeBOT"]:SetGradientAlpha(orientation,minR,minG,minB,minA,minR,minG,minB,minA)
self._backdrop["EdgeTOP"]:SetGradientAlpha(orientation,maxR,maxG,maxB,maxA,maxR,maxG,maxB,maxA)
self._backdrop["EdgeTOPRIGHTCORNER"]:SetGradientAlpha(orientation,maxR,maxG,maxB,maxA,maxR,maxG,maxB,maxA)
self._backdrop["EdgeBOTRIGHTCORNER"]:SetGradientAlpha(orientation,minR,minG,minB,minA,minR,minG,minB,minA)
self._backdrop["EdgeRIGHT"]:SetGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA)
end
end
 
--- API
-- New Backdrop function, for use with the new table layout defined above.
-- called when you pass a new table layout to SetBackdrop
function Backdrop:SetNewBackdrop(options)
self._backdrop["bgTexture"]:SetTexture(options.bgFile,hTile,vTile)
for k,v in pairs(edgePoints) do
self._backdrop["Edge"..k]:SetTexture(options.edgeFile[k],tilingOptions[k])
end
-- Copy options
self._backdrop.tileSize = options.tileSize
self._backdrop.tile = options.tile
self._backdrop.bgEdgeSize = options.edgeSize
-- Setup insets
self._backdrop:SetPoint("TOPLEFT",self,"TOPLEFT",-options.insets.left, options.insets.top)
self._backdrop:SetPoint("BOTTOMRIGHT",self,"BOTTOMRIGHT", options.insets.right, -options.insets.bottom)
local w,h = self:GetWidth()-options.edgeSize*2, self:GetHeight()-options.edgeSize*2
if options.edgeSize > 0 then
-- Attach croners
AttachNewCorners(self._backdrop)
-- Attach sides
AttachNewSides(self._backdrop,w,h)
end
-- Attach Background
self._backdrop.bgTexture:SetPoint("TOPLEFT", self._backdrop, "TOPLEFT", options.insets.left, -options.insets.top)
self._backdrop.bgTexture:SetPoint("BOTTOMRIGHT", self._backdrop, "BOTTOMRIGHT", -options.insets.right, options.insets.bottom)
if options.tile then
self._backdrop.bgTexture:SetTexCoord(0,w/options.tileSize, 0,h/options.tileSize)
end
end
 
--[[
local debug = false
 
if debug then
for k,v in pairs(_G) do
-- Reset any existing frames
if type(v) == "table" and v.GetObjectype and v:GetObjectType() == "Frame" then
local ob = v:GetBackdrop()
Backdrop:EhanceBackdrop(v)
v:SetBackdrop(ob)
end
end
CreateFrame = function(...)
local f = MakeFrame(...)
Backdrop:EnhanceBackdrop(f)
return f
end
end
--]]
\ No newline at end of file
mNameplates/Libs/AceConsole-3.0/AceConsole-3.0.xml New file
0,0 → 1,4
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Script file="AceConsole-3.0.lua"/>
</Ui>
\ No newline at end of file
mNameplates/Libs/AceConsole-3.0/AceConsole-3.0.lua New file
0,0 → 1,250
--- **AceConsole-3.0** provides registration facilities for slash commands.
-- You can register slash commands to your custom functions and use the `GetArgs` function to parse them
-- to your addons individual needs.
--
-- **AceConsole-3.0** can be embeded into your addon, either explicitly by calling AceConsole:Embed(MyAddon) or by
-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object
-- and can be accessed directly, without having to explicitly call AceConsole itself.\\
-- It is recommended to embed AceConsole, otherwise you'll have to specify a custom `self` on all calls you
-- make into AceConsole.
-- @class file
-- @name AceConsole-3.0
-- @release $Id: AceConsole-3.0.lua 878 2009-11-02 18:51:58Z nevcairiel $
local MAJOR,MINOR = "AceConsole-3.0", 7
 
local AceConsole, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
 
if not AceConsole then return end -- No upgrade needed
 
AceConsole.embeds = AceConsole.embeds or {} -- table containing objects AceConsole is embedded in.
AceConsole.commands = AceConsole.commands or {} -- table containing commands registered
AceConsole.weakcommands = AceConsole.weakcommands or {} -- table containing self, command => func references for weak commands that don't persist through enable/disable
 
-- Lua APIs
local tconcat, tostring, select = table.concat, tostring, select
local type, pairs, error = type, pairs, error
local format, strfind, strsub = string.format, string.find, string.sub
local max = math.max
 
-- WoW APIs
local _G = _G
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: DEFAULT_CHAT_FRAME, SlashCmdList, hash_SlashCmdList
 
local tmp={}
local function Print(self,frame,...)
local n=0
if self ~= AceConsole then
n=n+1
tmp[n] = "|cff33ff99"..tostring( self ).."|r:"
end
for i=1, select("#", ...) do
n=n+1
tmp[n] = tostring(select(i, ...))
end
frame:AddMessage( tconcat(tmp," ",1,n) )
end
 
--- Print to DEFAULT_CHAT_FRAME or given ChatFrame (anything with an .AddMessage function)
-- @paramsig [chatframe ,] ...
-- @param chatframe Custom ChatFrame to print to (or any frame with an .AddMessage function)
-- @param ... List of any values to be printed
function AceConsole:Print(...)
local frame = ...
if type(frame) == "table" and frame.AddMessage then -- Is first argument something with an .AddMessage member?
return Print(self, frame, select(2,...))
else
return Print(self, DEFAULT_CHAT_FRAME, ...)
end
end
 
 
--- Formatted (using format()) print to DEFAULT_CHAT_FRAME or given ChatFrame (anything with an .AddMessage function)
-- @paramsig [chatframe ,] "format"[, ...]
-- @param chatframe Custom ChatFrame to print to (or any frame with an .AddMessage function)
-- @param format Format string - same syntax as standard Lua format()
-- @param ... Arguments to the format string
function AceConsole:Printf(...)
local frame = ...
if type(frame) == "table" and frame.AddMessage then -- Is first argument something with an .AddMessage member?
return Print(self, frame, format(select(2,...)))
else
return Print(self, DEFAULT_CHAT_FRAME, format(...))
end
end
 
 
 
 
--- Register a simple chat command
-- @param command Chat command to be registered WITHOUT leading "/"
-- @param func Function to call when the slash command is being used (funcref or methodname)
-- @param persist if false, the command will be soft disabled/enabled when aceconsole is used as a mixin (default: true)
function AceConsole:RegisterChatCommand( command, func, persist )
if type(command)~="string" then error([[Usage: AceConsole:RegisterChatCommand( "command", func[, persist ]): 'command' - expected a string]], 2) end
 
if persist==nil then persist=true end -- I'd rather have my addon's "/addon enable" around if the author screws up. Having some extra slash regged when it shouldnt be isn't as destructive. True is a better default. /Mikk
 
local name = "ACECONSOLE_"..command:upper()
 
if type( func ) == "string" then
SlashCmdList[name] = function(input, editBox)
self[func](self, input, editBox)
end
else
SlashCmdList[name] = func
end
_G["SLASH_"..name.."1"] = "/"..command:lower()
AceConsole.commands[command] = name
-- non-persisting commands are registered for enabling disabling
if not persist then
if not AceConsole.weakcommands[self] then AceConsole.weakcommands[self] = {} end
AceConsole.weakcommands[self][command] = func
end
return true
end
 
--- Unregister a chatcommand
-- @param command Chat command to be unregistered WITHOUT leading "/"
function AceConsole:UnregisterChatCommand( command )
local name = AceConsole.commands[command]
if name then
SlashCmdList[name] = nil
_G["SLASH_" .. name .. "1"] = nil
hash_SlashCmdList["/" .. command:upper()] = nil
AceConsole.commands[command] = nil
end
end
 
--- Get an iterator over all Chat Commands registered with AceConsole
-- @return Iterator (pairs) over all commands
function AceConsole:IterateChatCommands() return pairs(AceConsole.commands) end
 
 
local function nils(n, ...)
if n>1 then
return nil, nils(n-1, ...)
elseif n==1 then
return nil, ...
else
return ...
end
end
 
 
--- Retreive one or more space-separated arguments from a string.
-- Treats quoted strings and itemlinks as non-spaced.
-- @param string The raw argument string
-- @param numargs How many arguments to get (default 1)
-- @param startpos Where in the string to start scanning (default 1)
-- @return Returns arg1, arg2, ..., nextposition\\
-- Missing arguments will be returned as nils. 'nextposition' is returned as 1e9 at the end of the string.
function AceConsole:GetArgs(str, numargs, startpos)
numargs = numargs or 1
startpos = max(startpos or 1, 1)
 
local pos=startpos
 
-- find start of new arg
pos = strfind(str, "[^ ]", pos)
if not pos then -- whoops, end of string
return nils(numargs, 1e9)
end
 
if numargs<1 then
return pos
end
 
-- quoted or space separated? find out which pattern to use
local delim_or_pipe
local ch = strsub(str, pos, pos)
if ch=='"' then
pos = pos + 1
delim_or_pipe='([|"])'
elseif ch=="'" then
pos = pos + 1
delim_or_pipe="([|'])"
else
delim_or_pipe="([| ])"
end
 
startpos = pos
 
while true do
-- find delimiter or hyperlink
local ch,_
pos,_,ch = strfind(str, delim_or_pipe, pos)
 
if not pos then break end
 
if ch=="|" then
-- some kind of escape
 
if strsub(str,pos,pos+1)=="|H" then
-- It's a |H....|hhyper link!|h
pos=strfind(str, "|h", pos+2) -- first |h
if not pos then break end
 
pos=strfind(str, "|h", pos+2) -- second |h
if not pos then break end
elseif strsub(str,pos, pos+1) == "|T" then
-- It's a |T....|t texture
pos=strfind(str, "|t", pos+2)
if not pos then break end
end
 
pos=pos+2 -- skip past this escape (last |h if it was a hyperlink)
 
else
-- found delimiter, done with this arg
return strsub(str, startpos, pos-1), AceConsole:GetArgs(str, numargs-1, pos+1)
end
 
end
 
-- search aborted, we hit end of string. return it all as one argument. (yes, even if it's an unterminated quote or hyperlink)
return strsub(str, startpos), nils(numargs-1, 1e9)
end
 
 
--- embedding and embed handling
 
local mixins = {
"Print",
"Printf",
"RegisterChatCommand",
"UnregisterChatCommand",
"GetArgs",
}
 
-- Embeds AceConsole into the target object making the functions from the mixins list available on target:..
-- @param target target object to embed AceBucket in
function AceConsole:Embed( target )
for k, v in pairs( mixins ) do
target[v] = self[v]
end
self.embeds[target] = true
return target
end
 
function AceConsole:OnEmbedEnable( target )
if AceConsole.weakcommands[target] then
for command, func in pairs( AceConsole.weakcommands[target] ) do
target:RegisterChatCommand( command, func, false, true ) -- nonpersisting and silent registry
end
end
end
 
function AceConsole:OnEmbedDisable( target )
if AceConsole.weakcommands[target] then
for command, func in pairs( AceConsole.weakcommands[target] ) do
target:UnregisterChatCommand( command ) -- TODO: this could potentially unregister a command from another application in case of command conflicts. Do we care?
end
end
end
 
for addon in pairs(AceConsole.embeds) do
AceConsole:Embed(addon)
end
mNameplates/Libs/LibNameplate-1.0/lib.xml New file
0,0 → 1,5
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Script file="LibNameplate-1.0.lua" />
 
</Ui>
\ No newline at end of file
mNameplates/Libs/LibNameplate-1.0/LibNameplate-1.0.lua New file
0,0 → 1,1501
--[[
Name: LibNameplate-1.0
Author(s): Cyprias (cyprias@gmail.com)
Documentation: http://www.wowace.com/addons/libnameplate-1-0/pages/main/
SVN: svn://svn.wowace.com/wow/libnameplate-1-0/mainline/trunk
Description: Alerts addons when a nameplate is shown or hidden. Has API to get info such as name, level, class, ect from the nameplate. LibNameplate tries to function with the default nameplates, Aloft, caelNamePlates and TidyPlates (buggy).
Dependencies: LibStub, CallbackHandler-1.0
]]
 
--[[
Todo
 
Notes
- hooking plates OnEnter requires the plates enable mouse. But doing that stops the mouseover ID being available.
]]
 
local MAJOR, MINOR = "LibNameplate-1.0", 22
if not LibStub then error(MAJOR .. " requires LibStub.") return end
 
local lib = LibStub:NewLibrary(MAJOR, MINOR)
if not lib then return end
 
lib.callbacks = lib.callbacks or LibStub("CallbackHandler-1.0"):New(lib)
if not lib.callbacks then error(MAJOR .. " CallbackHandler-1.0.") return end
 
-- Globals
local _G = _G
local tostring = tostring
local WorldFrame = WorldFrame
local select = select
local UnitExists = UnitExists
local UnitGUID = UnitGUID
local UnitName = UnitName
local pairs = pairs
local table_insert = table.insert
local GetMouseFocus = GetMouseFocus
local GetNumRaidMembers = GetNumRaidMembers
local GetNumPartyMembers = GetNumPartyMembers
local UnitIsUnit = UnitIsUnit
local GetRaidTargetIndex = GetRaidTargetIndex
local print = print
local table_getn = table.getn
local _ --localized underscore so FindGlobals doesn't bug me about it.
local IsAddOnLoaded = IsAddOnLoaded
local unpack = unpack
local math_floor = math.floor
local tonumber = tonumber
local UnitHealth = UnitHealth
local UnitHealthMax = UnitHealthMax
local UnitClass = UnitClass
local UnitInRange = UnitInRange
local table_remove = table.remove
 
--Conts
local scanDelay = 1 -- Scan for new nameplates every 1 seconds. We hook OnShow so this doesn't need to be done rapidly.
local updateDelay = 1 -- Update nameplate info every 1 seconds. This checks if a nameplate has a raid icon then trys to find the GUID to that icon.
 
 
local DEBUG = false
--[===[@debug@
DEBUG = true
--@end-debug@]===]
 
lib.realPlate = lib.realPlate or {}
lib.fakePlate = lib.fakePlate or {}
 
local function CmdHandler()
DEBUG = not DEBUG
end
_G.SlashCmdList["LIBNAMEPLATEDEBUG"] = CmdHandler
_G.SLASH_LIBNAMEPLATEDEBUG1 = "/lnbug"
local function debugPrint(...)
if DEBUG then
print(...)
end
end
lib.debugPrint = debugPrint
 
lib.nameplates = lib.nameplates or {}
lib.GUIDs = lib.GUIDs or {}
--~ lib.names = lib.names or {}
lib.onShowHooks = lib.onShowHooks or {}
lib.onHideHooks = lib.onHideHooks or {}
lib.onUpdateHooks = lib.onUpdateHooks or {}
--~ lib.setAlphaHooks = lib.setAlphaHooks or {}
lib.healthOnValueChangedHooks = lib.healthOnValueChangedHooks or {}
 
lib.plateGUIDs = lib.plateGUIDs or {}
lib.isOnScreen = lib.isOnScreen or {}
lib.isOnUpdating = lib.isOnUpdating or {}
lib.prevHealth = lib.prevHealth or {}
 
--Region locations
lib.name_region = lib.name_region or setmetatable({}, {__index = function(t,frame)
t[frame] = lib:GetNameRegion(frame)
return t[frame]
end
})
lib.level_region = lib.level_region or setmetatable({}, {__index = function(t,frame)
t[frame] = lib:GetLevelRegion(frame)
return t[frame]
end
})
lib.boss_region = lib.boss_region or setmetatable({}, {__index = function(t,frame)
t[frame] = lib:GetBossRegion(frame)
return t[frame]
end
})
lib.elite_region = lib.elite_region or setmetatable({}, {__index = function(t,frame)
t[frame] = lib:GetEliteRegion(frame)
return t[frame]
end
})
lib.threat_region = lib.threat_region or setmetatable({}, {__index = function(t,frame)
t[frame] = lib:GetThreatRegion(frame)
return t[frame]
end
})
lib.hightlight_region = lib.hightlight_region or setmetatable({}, {__index = function(t,frame)
t[frame] = lib:GetHightlightRegion(frame)
return t[frame]
end
})
lib.raidicon_region = lib.raidicon_region or setmetatable({}, {__index = function(t,frame)
t[frame] = lib:GetRaidIconRegion(frame)
return t[frame]
end
})
 
--bar locations
lib.health_bar = lib.health_bar or setmetatable({}, {__index = function(t,frame)
t[frame] = lib:GetHealthBar(frame)
return t[frame]
end
})
lib.cast_bar = lib.cast_bar or setmetatable({}, {__index = function(t,frame)
t[frame] = lib:GetCastBar(frame)
return t[frame]
end
})
 
 
lib.combatStatus = lib.combatStatus or {}
lib.threatStatus = lib.threatStatus or {}
 
--[[
TidyPlate region names
old: "threatGlow", "healthBorder", "castBorder", "castNostop", "spellIcon", "highlightTexture", "nameText", "levelText", "dangerSkull", "raidIcon", "eliteIcon"
new: "threatGlow", "healthborder", "castborder", "castnostop", "spellicon", "highlight", "name", "level", "dangerskull", "raidicon", "eliteicon"
TidyPlate child names
old: "healthBar", "castBar"
new: "castbar", "healthbar"
 
TidyPlate 'frame.regions' names.
castborder, castnostop, dangerskull, eliteicon, healthborder, highlight, level, name, raidicon, specialArt, specialText, specialText2, threatGlow, threatborder
TidyPlate 'frame.bars' names.
cast (real), castbar, health (real), healthbar,
]]
local regionNames = { "threatGlow", "healthBorder", "castBorder", "castNostop", "spellIcon", "highlightTexture", "nameText", "levelText", "dangerSkull", "raidIcon", "eliteIcon" }
local regionIndex = {}
for i, name in pairs(regionNames) do
regionIndex[name] = i
end
 
local barNames = { "healthBar", "castBar"}
local barIndex = {}
for i, name in pairs(barNames) do
barIndex[name] = i
end
 
--[[
these always return nil
frame:IsClampedToScreen(), frame:IsIgnoringDepth(), frame:IsMovable(), frame:IsToplevel(), frame:GetDepth(), frame:GetEffectiveDepth(),
 
]]
local function IsNamePlateFrame(frame)
if frame.extended or frame.aloftData then
--Tidyplates = extended, Aloft = aloftData
--They sometimes remove & replace the children so this needs to be checked first.
return true
end
 
if frame.done then --caelNP
return true
end
 
if frame:GetName() then
--~ debugPrint("IsNamePlateFrame","No name!")
return false
end
 
if frame:GetID() ~= 0 then
return false
end
 
if frame:GetObjectType() ~= "Frame" then
--~ debugPrint("IsNamePlateFrame","Not a frame!")
return false
end
 
if frame:GetNumChildren() == 0 then
--~ debugPrint("IsNamePlateFrame","No children?!!", frame:GetName(), frame.extended and frame.extended.bars)
return false
end
 
if frame:GetNumRegions() == 0 then
return false
end
 
return true
end
 
 
--~ local function ScanWorldFrameChildren(n, ...)
--~ for i = 1, n do
--~ local frame = select(i, ...)
--~ if frame:IsShown() and IsNamePlateFrame(frame) then
--~ if not lib.nameplates[frame] then
--~ lib:NameplateFirstLoad(frame)
--~ end
--~ end
--~ end
 
local function ScanWorldFrameChildren(frame, ...)
if not frame then return end
if frame:IsShown() and not lib.nameplates[frame] and IsNamePlateFrame(frame) then
lib:NameplateFirstLoad(frame)
end
return ScanWorldFrameChildren(...) --Call it self with the rest of the frames.
end
 
 
local prevChildren = 0
local function FindNameplates()
local curChildren = WorldFrame:GetNumChildren()
if curChildren ~= prevChildren then
prevChildren = curChildren
ScanWorldFrameChildren( WorldFrame:GetChildren() )
end
end
 
---------------------------
-- Get region locations
----------------------------
function lib:GetNameRegion(frame)
if frame.extended and frame.extended.regions and frame.extended.regions.name then --TidyPlates
return frame.extended.regions.name
 
elseif frame.aloftData and frame.aloftData.nameTextRegion then --Aloft
return frame.aloftData.nameTextRegion
 
elseif frame.oldname then --dNameplates
return frame.oldname
end
 
local region = select(regionIndex.nameText, frame:GetRegions())
return region
end
 
function lib:GetLevelRegion(frame)
if frame.extended and frame.extended.regions and frame.extended.regions.level then--TidyPlates
return frame.extended.regions.level
 
elseif frame.aloftData and frame.aloftData.levelTextRegion then --Aloft
return frame.aloftData.levelTextRegion
 
elseif frame.level then --dNameplates
return frame.level
end
 
return select(regionIndex.levelText, frame:GetRegions() )
end
 
function lib:GetBossRegion(frame)
if frame.extended and frame.extended.regions and frame.extended.regions.dangerskull then --tidyPlates
return frame.extended.regions.dangerskull
elseif frame.aloftData and frame.aloftData.bossIconRegion then --aloft
return frame.aloftData.bossIconRegion
elseif frame.boss then --dNameplates
return frame.boss
end
return select(regionIndex.dangerSkull, frame:GetRegions())
end
 
function lib:GetEliteRegion(frame)
if frame.extended and frame.extended.regions and frame.extended.regions.eliteicon then --tidyPlates
return frame.extended.regions.eliteicon
elseif frame.aloftData and frame.aloftData.stateIconRegion then --aloft
return frame.aloftData.stateIconRegion
elseif frame.elite then --dNameplates
return frame.elite
end
return select(regionIndex.eliteIcon, frame:GetRegions())
end
 
 
function lib:GetThreatRegion(frame)
if frame.extended and frame.extended.regions and frame.extended.regions.threatGlow then
return frame.extended.regions.threatGlow
elseif frame.aloftData and frame.aloftData.nativeGlowRegion then
return frame.aloftData.nativeGlowRegion
elseif frame.oldglow then --dNameplates
return frame.oldglow
end
 
return select(regionIndex.threatGlow, frame:GetRegions() )
end
 
 
function lib:GetHightlightRegion(frame)
if frame.extended then
if frame.extended.regions then
if frame.extended.regions.highlight then
return frame.extended.regions.highlight
elseif frame.extended.regions.highlightTexture then --old tidyplates
return frame.extended.regions.highlightTexture
end
end
elseif frame.aloftData and frame.aloftData.highlightRegion then
return frame.aloftData.highlightRegion
elseif frame.highlight then --dNameplates
return frame.highlight
end
 
return select(regionIndex.highlightTexture, frame:GetRegions())
end
 
 
function lib:GetRaidIconRegion(frame)
if frame.extended and frame.extended.regions and frame.extended.regions.raidicon then
return frame.extended.regions.raidicon
elseif frame.aloftData and frame.aloftData.raidIconRegion then
return frame.aloftData.raidIconRegion
end
return select(regionIndex.raidIcon, frame:GetRegions())
end
 
----------------------
-- Get bar frames
----------------------
function lib:GetHealthBar(frame)
if frame.extended and frame.extended.bars and frame.extended.bars.health then
return frame.extended.bars.health
--~ elseif frame.aloftData then
--Aloft changes the bar color. Our functions will have to use aloftData.originalHealthBarR
elseif frame.healthOriginal then --dNameplates
return frame.healthOriginal
end
return select(barIndex.healthBar, frame:GetChildren())
end
 
 
function lib:GetCastBar(frame)
if frame.extended and frame.extended.bars and frame.extended.bars.castbar then
return frame.extended.bars.castbar
elseif frame.aloftData and frame.aloftData.castBar then
return frame.aloftData.castBar
end
return select(barIndex.healthBar, frame:GetChildren())
end
 
------------------------------------------------------------------------------------------------------------------
local function HideMouseoverRegion(frame) --
-- If we move the camera angle while the mouse is over a plate, that plate won't hide the mouseover texture. --
-- So if we're mousing over someone's feet and a plate has the mouseover texture visible, --
-- it fools our code into thinking we're mousing over that plate. --
-- This can be recreated by placing the mouse over a nameplate then holding rightclick and moving the camera. --
-- If our UpdateNameplateInfo sees the mouseover texture still visible when we have no mouseoverID, it'll call --
-- this function to hide the texture. --
------------------------------------------------------------------------------------------------------------------
local region = lib.hightlight_region[frame]
if region and region.Hide then
region:Hide()
end
end
 
 
 
local function RecycleNameplate(frame)
--~ debugPrint("RecycleNameplate", frame)
 
lib.callbacks:Fire("LibNameplate_RecycleNameplate", lib.fakePlate[frame] or frame)
 
if lib.plateGUIDs[frame] then
lib.GUIDs[lib.plateGUIDs[frame]] = false
end
 
local plateName = lib:GetName(frame)
 
--~ if plateName and lib.names[plateName] then
--~ lib.names[plateName] = false
--~ end
 
lib.plateGUIDs[frame] = false
local fake = lib.fakePlate[frame]
if fake then
lib.realPlate[fake] = false
end
lib.fakePlate[frame] = false
end
 
local function FoundPlateGUID(frame, GUID, unitID)
lib.plateGUIDs[frame] = GUID
--~ lib.checkForHPUnitMatch[frame] = false
 
lib.GUIDs[GUID] = frame
lib.callbacks:Fire("LibNameplate_FoundGUID", lib.fakePlate[frame] or frame, GUID, unitID)
end
 
local function GetMouseoverGUID(frame)
local unitID = "mouseover"
if UnitExists(unitID) then
FoundPlateGUID(frame, UnitGUID(unitID), unitID)
end
end
 
local function FindPlateWithRaidIcon(iconNum)
for frame in pairs(lib.nameplates) do
if lib:IsMarked(frame) and lib:GetRaidIcon(frame) == iconNum then
return frame
end
end
return nil
end
 
local function CheckRaidIconOnUnit(unitID, frame, raidNum, from)
local targetID = unitID.."target"
local targetIndex
 
if UnitExists(targetID) and not UnitIsUnit("target", targetID) then
targetIndex = GetRaidTargetIndex(targetID)
if targetIndex and targetIndex == raidNum then
debugPrint("FindGUIDByRaidIcon", from, "Icon:"..tostring(raidNum), "unitID:"..tostring(targetID), "GUID:"..tostring(UnitGUID(targetID)))
FoundPlateGUID(frame, UnitGUID(targetID), targetID)
return true
end
end
return false
end
 
local function FindGUIDByRaidIcon(frame, raidNum, from)
local group, num = "", 0
if GetNumRaidMembers() > 1 then
group, num = "raid", GetNumRaidMembers()
elseif GetNumPartyMembers() > 0 then
group, num = "party", GetNumPartyMembers()
else
return
end
 
local unitID
for i = 1, num do
unitID = group..i;
if CheckRaidIconOnUnit(unitID, frame, raidNum, from) then
return
end
 
if UnitExists(unitID.."pet") then
if CheckRaidIconOnUnit(unitID.."pet", frame, raidNum, from) then
return
end
end
end
end
 
local function UpdateNameplateInfo(frame)
if lib:IsMouseover(frame) and not UnitExists("mouseover") then
HideMouseoverRegion(frame)
end
 
if not lib.plateGUIDs[frame] then
if lib:IsMouseover(frame) then
GetMouseoverGUID(frame)
elseif lib:IsMarked(frame) then
local raidNum = lib:GetRaidIcon(frame)
if raidNum and raidNum > 0 then
FindGUIDByRaidIcon(frame, raidNum, "UpdateNameplateInfo")
end
end
end
 
--~ debugPrint("Updated nameplate", lib:GetName(frame))
frame.lnpLastUpdate = 0
end
 
local function CheckUnitIDForMatchingHP(unitID, frameName, current, max)
local targetID = unitID.."target"
 
if UnitName(targetID) == frameName then
local health = UnitHealth(targetID)
local maxHealth = UnitHealthMax(targetID)
 
if health == current and maxHealth == max then
return true
end
end
return false
end
 
function lib:NewNameplateCheckHP(frame)
local bar = self.health_bar[frame]
if bar and bar.GetValue then --bar.GetMinMaxValues then
local _, max = bar:GetMinMaxValues()
--~ return tonumber(max or 0)
local current = bar:GetValue()
lib.prevHealth[frame] = current
 
if current > 0 and current ~= max then
 
 
local group, num = "", 0
if GetNumRaidMembers() > 1 then
group, num = "raid", GetNumRaidMembers()
elseif GetNumPartyMembers() > 0 then
group, num = "party", GetNumPartyMembers()
else
return
end
 
local possibleUnits = {}
 
local frameName = self:GetName(frame)
local unitID, targetID, targetIndex
for i = 1, num do
unitID = group..i;
if CheckUnitIDForMatchingHP(unitID, frameName, current, max) then
table_insert(possibleUnits, #possibleUnits+1, unitID.."target")
end
 
if UnitExists(unitID.."pet") then
if CheckUnitIDForMatchingHP(unitID.."pet", frameName, current, max) then
table_insert(possibleUnits, #possibleUnits+1, unitID.."pettarget")
end
end
 
end
 
if #possibleUnits == 1 then
--~ debugPrint("OnNameplateShow","Found nameplate HP match", self:GetName(frame), UnitName(possibleUnits[1]))
FoundPlateGUID(frame, UnitGUID(possibleUnits[1]), possibleUnits[1])
return true
end
 
end
end
end
 
 
function lib.OnNameplateShow(frame, ...)
--~ local plateName = lib:GetName(frame)
--~ debugPrint("OnNameplateShow",frame, plateName)
 
lib:SetupNameplate(frame)
lib:NewNameplateCheckHP(frame)
end
local function ourOnShow(...) return lib.OnNameplateShow(...) end
 
function lib.OnNameplateHide(frame, ...)
lib.isOnScreen[frame] = false
lib.isOnUpdating[frame] = false
lib.combatStatus[frame] = false
--~ lib.threatStatus[frame] = "LOW" --Don't reset onHide.
--~ lib.checkForHPUnitMatch[frame] = false
 
RecycleNameplate(frame)
end
local function ourOnHide(...) return lib.OnNameplateHide(...) end
 
--[[
local function ourOnHide(self, ...)
lib.isOnScreen[self] = false
RecycleNameplate(self)
end
]]
 
--[[]]
 
lib.callbacksRegistered = lib.callbacksRegistered or {}
 
function lib.callbacks:OnUsed(target, eventname)
lib.callbacksRegistered[eventname] = lib.callbacksRegistered[eventname] or {}
table_insert(lib.callbacksRegistered[eventname], #lib.callbacksRegistered[eventname]+1, target)
--~ debugPrint("OnUsed", target, eventname)
 
lib.ModifyOnUpdate()
end
 
function lib.callbacks:OnUnused(target, eventname)
--~ debugPrint("OnUnused", target, eventname)
 
if lib.callbacksRegistered[eventname] then
for i=1, #lib.callbacksRegistered[eventname] do
if lib.callbacksRegistered[eventname][i] == target then
table_remove(lib.callbacksRegistered[eventname], i)
break
end
end
end
 
lib.ModifyOnUpdate()
end
 
 
local function CheckForFakePlate(frame)
if not lib.fakePlate[frame] and frame.extended then
lib.realPlate[frame.extended] = frame
lib.fakePlate[frame] = frame.extended
 
lib.callbacks:Fire("LibNameplate_RecycleNameplate", frame)--Hide real plate so addon unhook their stuff.
lib.callbacks:Fire("LibNameplate_NewNameplate", lib.fakePlate[frame])
end
end
 
local function CheckCombatStatus(frame)
local inCombat = lib:IsInCombat(frame)
if lib.combatStatus[frame] ~= inCombat then
lib.combatStatus[frame] = inCombat
--~ debugPrint("OnNameplateUpdate D", inCombat, "LibNameplate_CombatChange")
lib.callbacks:Fire("LibNameplate_CombatChange", lib.fakePlate[frame] or frame, inCombat)
end
end
 
local function CheckThreatStatus(frame)
local threatSit = lib:GetThreatSituation(frame)
if lib.threatStatus[frame] ~= threatSit then
lib.threatStatus[frame] = threatSit
--~ debugPrint("CheckThreatStatus D", threatSit, "LibNameplate_ThreatChange")
lib.callbacks:Fire("LibNameplate_ThreatChange", lib.fakePlate[frame] or frame, threatSit)
end
end
 
function lib.OnNameplateUpdate(frame, elapsed, ...)
lib.isOnUpdating[frame] = true --to make sure our hooks don't break.
if frame.lnpCheckForTarget then --Check on the first OnUpdate after the frame's shown.
frame.lnpCheckForTarget = false
if not lib.plateGUIDs[frame] and frame:IsShown() and ((frame:GetAlpha() == 1) and UnitExists("target")) then
FoundPlateGUID(frame, UnitGUID("target"), "target")
end
end
 
frame.lnpLastUpdate = (frame.lnpLastUpdate or 0) + elapsed
if frame.lnpLastUpdate > updateDelay then
UpdateNameplateInfo(frame)
 
CheckForFakePlate(frame)
CheckCombatStatus(frame)
CheckThreatStatus(frame)
elseif frame.updateCountdown > 0 then
--Threat doesn't get updated until the first OnUpdate. So OnShow sometimes sees the threat of the previous nameplate owner.
--So I wait unit the 2nd OnUpdate to check threat status.
frame.updateCountdown = frame.updateCountdown - 1
if frame.updateCountdown == 0 then
CheckThreatStatus(frame)
end
end
end
local function ourOnUpdate(...) return lib.OnNameplateUpdate(...) end
 
 
--[[
function lib.OnSetAlpha(frame, ...)
local plateName = lib:GetName(frame)
debugPrint("OnSetAlpha", plateName, ...)
end
local function ourSetAlpha(...) return lib.OnSetAlpha(...) end
]]
 
--~ lib.checkForHPUnitMatch = lib.checkForHPUnitMatch or {}
 
--------------------------------------------------------------------------------------
function lib.healthOnValueChanged(frame, ...) --
-- This fires before OnShow fires and the regions haven't been updated yet. --
-- So I make sure lib.isOnScreen[plate] is true before working on the HP change. --
--------------------------------------------------------------------------------------
local plate = frame:GetParent()
local currentHP = ...
 
--strange, when a nameplate's not on screen, we still get HP changes. It's not relyable but might be of use somehow...
--~ if plate and plate:IsShown() and not lib.prevHealth[plate] or lib.prevHealth[plate] ~= currentHP then
if plate and lib.isOnScreen[plate] and (not lib.prevHealth[plate] or lib.prevHealth[plate] ~= currentHP) then
lib.callbacks:Fire("LibNameplate_HealthChange", plate, ...)
local plateName = lib:GetName(plate)
--~ debugPrint("OnValueChanged", plateName, ...)
 
if not lib.plateGUIDs[plate] then
 
--~ lib.checkForHPUnitMatch[plate] = true
 
--~ debugPrint("healthOnValueChanged",plate, "Checking HP change on "..tostring(plateName), ..., "onScreen:"..tostring(lib.isOnScreen[plate]))
lib:NewNameplateCheckHP(plate)
 
end
 
end
end
local function ourHealthOnValueChanged(...) return lib.healthOnValueChanged(...) end
 
--[[
--~ --Castbars are only shown on your target's nameplate. No sense adding callbacks for this.
--~ --Castbar show
local testing = {}
lib.onCastbarShowHooks = lib.onCastbarShowHooks or {}
function lib.OnCastbarShow(self, ...)
if not testing[self] then
if UnitExists("target") and (UnitCastingInfo("target") or UnitChannelInfo("target")) then
testing[self] = true
 
debugPrint("OnCastbarShow 2", UnitCastingInfo("target"), UnitChannelInfo("target"))
end
end
end
local function ourCastbarShow(...) return lib.OnCastbarShow(...) end
 
--~ --castbar hide
lib.onCastbarHideHooks = lib.onCastbarHideHooks or {}
function lib.OnCastbarHide(self, ...)
end
local function ourCastbarHide(...) return lib.OnCastbarHide(...) end
]]
 
local testing = false
 
function lib:HookNameplate(frame)
if frame:HasScript("OnHide") and not self.onHideHooks[frame] then
self.onHideHooks[frame] = true
frame:HookScript("OnHide", ourOnHide)
end
 
if frame:HasScript("OnShow") and not self.onShowHooks[frame] then
self.onShowHooks[frame] = true
frame:HookScript("OnShow", ourOnShow)
end
 
if frame:HasScript("OnUpdate") and not self.onUpdateHooks[frame] then
self.onUpdateHooks[frame] = true
frame:HookScript("OnUpdate", ourOnUpdate)
end
 
--[[if not self.setAlphaHooks[frame] then --nameRegion:HasScript("SetText") and
self.setAlphaHooks[frame] = true
hooksecurefunc(frame, "SetAlpha", ourSetAlpha)
end]]
 
local healthBar = self.health_bar[frame]
if healthBar and not self.healthOnValueChangedHooks[frame] then
self.healthOnValueChangedHooks[frame] = true
healthBar:HookScript("OnValueChanged", ourHealthOnValueChanged)
end
end
 
function lib:NameplateFirstLoad(frame)
if not lib.nameplates[frame] then
--Hook handlers.
self:HookNameplate(frame)
 
--Save frame's combat status as false.
if self.combatStatus[frame] == nil then
self.combatStatus[frame] = false --not in combat
end
 
if self.threatStatus[frame] == nil then
self.threatStatus[frame] = "LOW"
end
 
lib:SetupNameplate(frame)
end
end
 
function lib:SetupNameplate(frame)
self.isOnScreen[frame] = true --to make sure our hooks don't break.
 
local plateName = self:GetName(frame)
self.nameplates[frame] = plateName
--~ self.names[plateName] = frame
--~ local plateType = self:GetType(frame)
--~ local plateCombat = self:IsInCombat(frame)
--~ debugPrint("SetupNameplate", plateName, plateType, plateCombat)
 
lib.threatStatus[frame] = self:GetThreatSituation(frame) --Save it during OnShow. Sometimes this returns the threat of the previous owner of the nameplate. Our OnUpdate will check for changes and fire ThreatChanged callback.
 
--TidyPlates replace the orginal frame with their own.
--Lets save this and give that frame to addons. It's better for anchors.
if frame.extended and not self.fakePlate[frame] then
self.fakePlate[frame] = frame.extended
self.realPlate[frame.extended] = frame
 
--Without this was causing problems with PlateBuffs where it was never told the real plate was gone.
self.callbacks:Fire("LibNameplate_RecycleNameplate", frame)
end
 
self.callbacks:Fire("LibNameplate_NewNameplate", self.fakePlate[frame] or frame)
 
frame.lnpCheckForTarget = true
 
 
UpdateNameplateInfo(frame)
--~ frame.lnpLastUpdate = 100 --make sure the next OnUpdate runs our code.
frame.updateCountdown = 2
end-- /lnbug
 
local function CheckForTargetGUID()
local unitID = "target"
local GUID
for frame in pairs(lib.nameplates) do
if lib:IsTarget(frame) then
lib.targeted = frame
if not lib.plateGUIDs[frame] then
FoundPlateGUID(frame, UnitGUID(unitID), unitID)
end
lib.callbacks:Fire("LibNameplate_TargetNameplate", lib.fakePlate[frame] or frame)
return
end
end
--~ debugPrint("Failed to find target GUID")
end
 
local function MainOnEvent(frame, event, ...)
if event == "UPDATE_MOUSEOVER_UNIT" then
if GetMouseFocus():GetName() == "WorldFrame" then
local i = 0
local mouseoverPlate
for frame in pairs(lib.nameplates) do
if frame:IsShown() and lib:IsMouseover(frame) then
i = i + 1
mouseoverPlate = frame
 
end
end
if i == 1 then
if not lib.plateGUIDs[mouseoverPlate] then
GetMouseoverGUID(mouseoverPlate)
end
lib.callbacks:Fire("LibNameplate_MouseoverNameplate", lib.fakePlate[mouseoverPlate] or mouseoverPlate)
elseif i > 1 then
debugPrint(i.." mouseover frames")
end
 
end
 
elseif event == "PLAYER_TARGET_CHANGED" then
lib.targeted = nil
 
if UnitExists("target") then
lib.checkTarget:Show() --Target's nameplate alpha isn't update until the next OnUpdate fires.
end
 
elseif event == "UNIT_TARGET" then
local unitID = ...
local targetID = unitID.."target"
if UnitExists(targetID) and not UnitIsUnit("player", unitID) and UnitInRange(unitID) then
local targetGUID = UnitGUID(targetID)
local iconNum = GetRaidTargetIndex(targetID)
if iconNum and iconNum > 0 then
local foundPlate = FindPlateWithRaidIcon(iconNum)
if foundPlate and not lib.plateGUIDs[foundPlate] then
--~ debugPrint(event, "Found raid icon on ", UnitName(unitID), "'s target", UnitName(targetID), "icon:"..tostring(iconNum))
FoundPlateGUID(foundPlate, targetGUID, targetID)
end
end
 
 
if lib.GUIDs[targetGUID] and lib.GUIDs[targetGUID]:IsShown() then
return
end
 
local health = UnitHealth(targetID)
local maxHealth = UnitHealthMax(targetID)
if health > 0 and health ~= maxHealth then
 
local foundPlate = lib:GetNameplateByHealth(health, maxHealth)
--~ debugPrint(event, "A", foundPlate, health, maxHealth)
if foundPlate and not lib.plateGUIDs[foundPlate] then
local name = UnitName(targetID)
if name == lib:GetName(foundPlate) then
--~ local class = lib:GetClass(foundPlate)
--~ local _, unitClass = UnitClass(targetID)
--~
--~ debugPrint(event, "B", foundPlate, class, unitClass)
 
--~ if not class or class == unitClass then
--~ return lib.fakePlate[frame] or frame
 
--~ debugPrint(event, "C", "Found nameplate matching "..UnitName(unitID).."'s target.", UnitName(targetID))
 
FoundPlateGUID(foundPlate, targetGUID, targetID)
 
 
--~ end
end
end
end
 
 
 
end
 
elseif event == "RAID_TARGET_UPDATE" then
for frame in pairs(lib.nameplates) do
if frame:IsShown() and not lib.plateGUIDs[frame] and lib:IsMarked(frame) then
local raidNum = lib:GetRaidIcon(frame)
if raidNum and raidNum > 0 then
FindGUIDByRaidIcon(frame, raidNum, event)
end
end
end
--~ elseif event == "PLAYER_ENTERING_WORLD" then
--~ debugPrint(event, MAJOR, _G.TidyPlates, _G.Aloft)
--~ if _G.TidyPlates then
--~ tidyPlatesRunning = true
--~ elseif _G.Aloft then
--~ aloftRunning = true
--~ if IsAddOnLoaded("caelNamePlates") then
--~ scanDelay = 0.1 --cael breaks our onhide/onshow hooks.
--~ elseif IsAddOnLoaded("dNameplates") then
--~ scanDelay = 0.1 --cael breaks our onhide/onshow hooks.
--~ end
 
end
end
 
 
 
lib.frame = lib.frame or CreateFrame("Frame")
lib.frame.lastUpdate = 0
lib.frame.lastHPCheck = 0
lib.frame:SetScript("OnEvent", MainOnEvent)
lib.frame:RegisterEvent('UPDATE_MOUSEOVER_UNIT')
lib.frame:RegisterEvent('PLAYER_TARGET_CHANGED')
lib.frame:RegisterEvent('UNIT_TARGET')
lib.frame:RegisterEvent('RAID_TARGET_UPDATE')
lib.frame:RegisterEvent('PLAYER_ENTERING_WORLD')
lib.frame:SetScript("OnUpdate", function(this, elapsed)
FindNameplates()
end)
 
--To find our target's nameplate, we need to wait for 1 OnUpdate to fire after PLAYER_TARGET_CHANGED.
lib.checkTarget = lib.checkTarget or CreateFrame("Frame")
lib.checkTarget:Hide()
lib.checkTarget:SetScript("OnUpdate", function(this, elapsed)
CheckForTargetGUID()
this:Hide()
end)
 
 
lib.fixHooks = lib.fixHooks or CreateFrame("Frame")
lib.fixHooks.updateThrottle = 1 --fire once a second.
lib.fixHooks.lastUpdate = 0
lib.fixHooks:SetScript("OnUpdate", function(this, elapsed)
--code searches for broken OnShow/OnHide hooks.
--some nameplate addons will use SetScript instead of HookScript and breaks our hooks.
this.lastUpdate = this.lastUpdate - elapsed
if this.lastUpdate <= 0 then
this.lastUpdate = this.updateThrottle
for frame, value in pairs(lib.isOnScreen) do
if (value == true and not frame:IsShown()) then --OnHide fail
debugPrint("OnHide fail", frame, value, frame:IsShown())
lib.onHideHooks[frame] = false
lib.isOnScreen[frame] = false
lib:HookNameplate(frame)
lib.OnNameplateHide(frame)
 
elseif (value == false and frame:IsShown()) then --OnShow fail
debugPrint("OnShow fail", frame, value, frame:IsShown())
lib.onShowHooks[frame] = false
lib.isOnScreen[frame] = false
lib:HookNameplate(frame)
lib:SetupNameplate(frame, true)
 
end
end
for frame, value in pairs(lib.isOnUpdating) do
if value == false and frame:IsShown() then
debugPrint("OnUpdate fail?")
lib.onUpdateHooks[frame] = false
lib:HookNameplate(frame)
end
end
end
end)
 
 
--------------------- API ------------------
local raidIconTexCoord = {--from GetTexCoord. input is ULx and ULy (first 2 values).
[0] = {
[0] = 1, --star
[0.25] = 5, --moon
},
[0.25] = {
[0] = 2, --circle
[0.25] = 6, --square
},
[0.5] = {
[0] = 3, --star
[0.25] = 7, --cross
},
[0.75] = {
[0] = 4, --star
[0.25] = 8, --skull
},
}
 
 
--Support functions for API.
local function reactionByColor(red, green, blue, a)
if red < .01 and blue < .01 and green > .99 then return "FRIENDLY", "NPC"
elseif red < .01 and blue > .99 and green < .01 then return "FRIENDLY", "PLAYER"
elseif red > .99 and blue < .01 and green > .99 then return "NEUTRAL", "NPC"
elseif red > .99 and blue < .01 and green < .01 then return "HOSTILE", "NPC"
else return "HOSTILE", "PLAYER" end
end
--[[
RAID_CLASS_COLORS
["HUNTER"] = { r = 0.67, g = 0.83, b = 0.45 },
["WARLOCK"] = { r = 0.58, g = 0.51, b = 0.79 },
["PRIEST"] = { r = 1.0, g = 1.0, b = 1.0 },
["PALADIN"] = { r = 0.96, g = 0.55, b = 0.73 },
["MAGE"] = { r = 0.41, g = 0.8, b = 0.94 },
["ROGUE"] = { r = 1.0, g = 0.96, b = 0.41 },
["DRUID"] = { r = 1.0, g = 0.49, b = 0.04 },
["SHAMAN"] = { r = 0.0, g = 0.44, b = 0.87 },
["WARRIOR"] = { r = 0.78, g = 0.61, b = 0.43 },
["DEATHKNIGHT"] = { r = 0.77, g = 0.12 , b = 0.23 },
]]
 
local colorToClass = {}
local function pctToInt(number) return math_floor((100*number) + 0.5) end
for classname, color in pairs(RAID_CLASS_COLORS) do
colorToClass["C"..pctToInt(color.r)+pctToInt(color.g)+pctToInt(color.b)] = classname
end
 
local function threatByColor( region )
if not region:IsShown() then return "LOW" end
 
local redCan, greenCan, blueCan, alphaCan = region:GetVertexColor()
if greenCan > .7 then return "MEDIUM" end
if redCan > .7 then return "HIGH" end
end
 
 
local function combatByColor(r, g, b, a)
return (r > .5 and g < .5)
end
 
 
local function GetHealthBarColor(frame)
if frame.aloftData then
local r, g, b = frame.aloftData.originalHealthBarR, frame.aloftData.originalHealthBarG, frame.aloftData.originalHealthBarB
return r, g, b
end
 
if frame.originalR and frame.originalG and frame.originalB then
--dNamePlates changes the color of the healthbar. r7 now saves the original colors. TY Dawn.
return frame.originalR, frame.originalG, frame.originalB
end
 
local bar = lib.health_bar[frame]
if bar and bar.GetStatusBarColor then
return bar:GetStatusBarColor()
end
return nil
end
 
lib.noColorName = lib.noColorName or setmetatable({}, {__index = function(t,inputString)
if inputString then
if inputString:find("|c") then
local input = inputString
local find = inputString:find("|c")
local inputString = inputString:sub(find+10)
inputString = inputString:gsub("|r", "")
t[input] = inputString
return inputString
end
t[inputString] = inputString
end
return inputString or "UNKNOWN"
end})
 
lib.noColorNum = lib.noColorNum or setmetatable({}, {__index = function(t,inputString)
if inputString then
if inputString:find("|c") then
local input = inputString
local find = inputString:find("|c")
local inputString = inputString:sub(find+10)
inputString = inputString:gsub("|r", "")
inputString = tonumber(inputString or 0)
t[input] = inputString
return inputString
end
t[inputString] = tonumber(inputString or 0)
end
return inputString or 0
end})
 
--~ --------------------------------------------------------------
--~ local function RemoveHexColor(inputString) --
--~ -- Remove hex color code from string. --
--~ -- Aloft uses hex codes to color name and level regions. --
--~ --------------------------------------------------------------
--~ if inputString and inputString:find("|c") then
--~ local find = inputString:find("|c")
--~ inputString = inputString:sub(find+10)
--~ inputString = inputString:gsub("|r", "")
--~ end
--~ return inputString
--~ end
 
--API
 
function lib:GetName(frame)
local frame = self.realPlate[frame] or frame
 
local nameRegion = self.name_region[frame]
if nameRegion and nameRegion.GetText then
--~ return RemoveHexColor( nameRegion:GetText() )
return self.noColorName[ nameRegion:GetText() ]
 
end
 
return nil
end
 
 
function lib:GetLevel(frame)
local frame = self.realPlate[frame] or frame
local region = self.level_region[frame]
if region and region.GetText then
--~ return tonumber( RemoveHexColor( region:GetText() ) )
return self.noColorNum[ region:GetText() ]
 
end
return 0
end
 
 
function lib:GetScale(frame)
local frame = self.realPlate[frame] or frame
if frame.extended then
frame = frame.extended
end
return frame:GetScale()
end
 
function lib:GetVisibleFrame(frame)
local frame = self.realPlate[frame] or frame
if frame.extended then
frame = frame.extended
end
return frame
end
 
 
function lib:GetReaction(frame)
local frame = self.realPlate[frame] or frame
 
local r,g,b = GetHealthBarColor(frame)
if r then
return reactionByColor(r, g, b )
end
 
return nil
end
 
function lib:GetType(frame)
local frame = self.realPlate[frame] or frame
 
local r, g, b = GetHealthBarColor(frame)
if r then
return select(2, reactionByColor( r, g, b ) )
end
 
return nil
end
 
 
 
function lib:IsBoss(frame)
local frame = self.realPlate[frame] or frame
 
local region = self.boss_region[frame]
if region and region.IsShown then
return region:IsShown() and true or false
end
 
return nil
end
 
 
--This will return nil if we're not in a PvP zone (like in cities)
function lib:GetClass(frame)
local frame = self.realPlate[frame] or frame
 
local r, g, b = GetHealthBarColor(frame)
if r then
return colorToClass["C"..pctToInt(r)+pctToInt(g)+pctToInt(b)] or nil
end
 
return nil
end
 
function lib:IsElite(frame)
local frame = self.realPlate[frame] or frame
 
local region = self.elite_region[frame]
if region and region.IsShown then
return region:IsShown() and true or false
end
return nil
end
 
 
--[[
Note: GetThreatSituation sometimes returns wrong info on OnShow (NewNameplate) event. It sometimes returns the previous owner of the nameplate's threat.
]]
function lib:GetThreatSituation(frame)
local frame = self.realPlate[frame] or frame
 
local region = self.threat_region[frame]
if region and region.GetVertexColor then
return threatByColor(region)
end
 
return nil
end
 
function lib:IsTarget(frame)
local frame = self.realPlate[frame] or frame
return frame:IsShown() and frame:GetAlpha() == 1 and UnitExists("target") or false
end
 
function lib:GetHealthMax(frame)
local frame = self.realPlate[frame] or frame
 
local bar = self.health_bar[frame]
if bar and bar.GetMinMaxValues then
local _, max = bar:GetMinMaxValues()
return tonumber(max or 0)
end
return nil
end
 
function lib:GetHealth(frame)
local frame = self.realPlate[frame] or frame
 
local bar = self.health_bar[frame]
if bar and bar.GetValue then
return bar:GetValue()
end
return nil
end
 
function lib:GetRaidIcon(frame)
local frame = self.realPlate[frame] or frame
 
local region = self.raidicon_region[frame]
if region and region.IsShown and region:IsShown() and region.GetTexCoord then
local ULx,ULy = region:GetTexCoord() --,LLx,LLy,URx,URy,LRx,LRy
 
if ULx and ULy then
return raidIconTexCoord[ULx] and raidIconTexCoord[ULx][ULy] or 0
end
end
 
return nil
end
 
function lib:IsMouseover(frame)
local frame = self.realPlate[frame] or frame
 
local region = self.hightlight_region[frame]
if region and region.IsShown then
return region:IsShown() and true or false
end
 
return nil
end
 
 
function lib:IsCasting(frame)
local frame = self.realPlate[frame] or frame
 
local bar = self.cast_bar[frame]
if bar and bar.IsShown then
return bar:IsShown() and true or false
end
return nil
end
 
 
function lib:IsInCombat(frame)
local frame = self.realPlate[frame] or frame
 
local region = self.name_region[frame]
if region and region.GetTextColor then
return combatByColor( region:GetTextColor() ) and true or false
end
 
return nil
end
 
function lib:IsMarked(frame)
local frame = self.realPlate[frame] or frame
 
local region = self.raidicon_region[frame]
if region and region.IsShown then
return region:IsShown() and true or false
end
 
return nil
end
 
 
function lib:GetGUID(frame)
local frame = self.realPlate[frame] or frame
return self.plateGUIDs[frame]
end
 
 
function lib:GetTargetNameplate()
if self.targeted and self.targeted:IsShown() then
return self.fakePlate[self.targeted] or self.targeted
end
end
 
function lib:GetNameplateByGUID(GUID)
if self.GUIDs[GUID] and self.GUIDs[GUID]:IsShown() then
return self.fakePlate[self.GUIDs[GUID]] or self.GUIDs[GUID]
end
end
 
 
function lib:GetNameplateByName(name, maxHp)
--~ if self.names[name] and self.names[name]:IsShown() then
--~ return self.fakePlate[self.names[name]] or self.names[name]
--~ end
 
local bar, barMax
for frame in pairs(self.nameplates) do
if frame:IsShown() then
if name == lib:GetName(frame) then
if not maxHp then
return self.fakePlate[frame] or frame
end
bar = self.health_bar[frame]
if bar and bar.GetMinMaxValues then
_, barMax = bar:GetMinMaxValues()
if barMax == maxHp then
return self.fakePlate[frame] or frame
end
end
end
end
end
end
 
function lib:GetNameplateByUnit(unitID)
if UnitIsUnit(unitID, "target") then
return self:GetTargetNameplate()
end
local GUID = UnitGUID(unitID)
if self.GUIDs[GUID] and self.GUIDs[GUID]:IsShown() then
return self.fakePlate[self.GUIDs[GUID]] or self.GUIDs[GUID]
end
 
local health = UnitHealth(unitID)
local maxHealth = UnitHealthMax(unitID)
local frame = self:GetNameplateByHealth(health, maxHealth)
local name = UnitName(unitID)
if frame then
if name == lib:GetName(frame) then
--~ local class = self:GetClass(frame)
--~ local _, unitClass = UnitClass(unitID)
--~
--~ if not class or class == unitClass then
return self.fakePlate[frame] or frame
--~ end
end
end
 
 
return self:GetNameplateByName(name, maxHealth)
end
 
--Returns all known nameplates. Not just the one's visible.
function lib:GetAllNameplates()
local frames = {}
for frame in pairs(self.nameplates) do
table_insert(frames, #frames+1, self.fakePlate[frame] or frame)
end
return #frames, unpack(frames)
end
 
function lib:GetNameplateByHealth(current, max)
local possibleFrames = {}
local bar, barMax, barCurrent
for frame in pairs(self.nameplates) do
if frame:IsShown() then
bar = self.health_bar[frame]
 
if bar and bar.GetMinMaxValues then
_, barMax = bar:GetMinMaxValues()
if barMax == max then
if bar:GetValue() == current then
table_insert(possibleFrames, #possibleFrames+1, frame)
end
end
 
end
 
--~ table_insert(frames, #frames+1, self.fakePlate[frame] or frame)
end
end
 
 
 
--~ debugPrint("GetNameplateByHealth C", #possibleFrames)
 
if #possibleFrames == 1 then
return possibleFrames[1]
end
return nil
end
 
 
 
--[[
Testing changes to our OnUpdate hook function.
I'm trying to change the OnUpdate function based on which callbacks are registered. Right now it only checks Combat and Threat changed callbacks.
Hopfully this is coded right because any errors won't say which line is acting up.
]]
 
local loadstring = loadstring
local setmetatable = setmetatable
local setfenv = setfenv
 
function lib.ModifyOnUpdate()
local code = [[
local frame, elapsed = ...
]]
 
code = code..[[
lib.isOnUpdating[frame] = true --to make sure our hooks don't break.
if frame.lnpCheckForTarget then --Check on the first OnUpdate after the frame's shown.
frame.lnpCheckForTarget = false
if not lib.plateGUIDs[frame] and frame:IsShown() and ((frame:GetAlpha() == 1) and UnitExists("target")) then
FoundPlateGUID(frame, UnitGUID("target"), "target")
end
end
 
frame.lnpLastUpdate = (frame.lnpLastUpdate or 0) + elapsed
if frame.lnpLastUpdate > updateDelay then
UpdateNameplateInfo(frame)
CheckForFakePlate(frame)
]]
 
--Only check for combatchange if callback is registered.
if lib.callbacksRegistered["LibNameplate_CombatChange"] and #lib.callbacksRegistered["LibNameplate_CombatChange"] > 0 then
code = code..[[
CheckCombatStatus(frame)
]]
end
 
--Only check if threat changed if callback is registred.
if lib.callbacksRegistered["LibNameplate_ThreatChange"] and #lib.callbacksRegistered["LibNameplate_ThreatChange"] > 0 then
code = code..[[
CheckThreatStatus(frame)
elseif frame.updateCountdown > 0 then
--Threat doesn't get updated until the first OnUpdate. So OnShow sometimes sees the threat of the previous nameplate owner.
--So I wait unit the 2nd OnUpdate to check threat status.
frame.updateCountdown = frame.updateCountdown - 1
if frame.updateCountdown == 0 then
CheckThreatStatus(frame)
end
]]
end
code = code..[[
end
]]--Close our if statement.
 
 
local update = loadstring(code, "OnUpdateString")
 
local smallenv = {--Create our environment so the script can access these functions/values.
lib = lib,
FoundPlateGUID = FoundPlateGUID,
UpdateNameplateInfo = UpdateNameplateInfo,
CheckForFakePlate = CheckForFakePlate,
CheckCombatStatus = CheckCombatStatus,
CheckThreatStatus = CheckThreatStatus,
updateDelay = updateDelay,
};
 
--~ setmetatable(smallenv, {__index = _G}) --Make sure it can access global functions.
setmetatable(smallenv, {__index = function(t,i) --Our script is trying to access something not in our environment.
t[i] = _G[i] --Create a upvalue in our environment. I hope this will give faster lookup times then making '__Index = _G' would.
return t[i]
end})
 
setfenv(update, smallenv);--Set our update function to use our environment.
 
lib.OnNameplateUpdate = update
end
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIWidget-ColorPicker.lua New file
0,0 → 1,186
--[[-----------------------------------------------------------------------------
ColorPicker Widget
-------------------------------------------------------------------------------]]
local Type, Version = "ColorPicker", 20
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local pairs = pairs
 
-- WoW APIs
local CreateFrame, UIParent = CreateFrame, UIParent
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: ShowUIPanel, HideUIPanel, ColorPickerFrame, OpacitySliderFrame
 
--[[-----------------------------------------------------------------------------
Support functions
-------------------------------------------------------------------------------]]
local function ColorCallback(self, r, g, b, a, isAlpha)
if not self.HasAlpha then
a = 1
end
self:SetColor(r, g, b, a)
if ColorPickerFrame:IsVisible() then
--colorpicker is still open
self:Fire("OnValueChanged", r, g, b, a)
else
--colorpicker is closed, color callback is first, ignore it,
--alpha callback is the final call after it closes so confirm now
if isAlpha then
self:Fire("OnValueConfirmed", r, g, b, a)
end
end
end
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function Control_OnEnter(frame)
frame.obj:Fire("OnEnter")
end
 
local function Control_OnLeave(frame)
frame.obj:Fire("OnLeave")
end
 
local function ColorSwatch_OnClick(frame)
HideUIPanel(ColorPickerFrame)
local self = frame.obj
if not self.disabled then
ColorPickerFrame:SetFrameStrata("FULLSCREEN_DIALOG")
 
ColorPickerFrame.func = function()
local r, g, b = ColorPickerFrame:GetColorRGB()
local a = 1 - OpacitySliderFrame:GetValue()
ColorCallback(self, r, g, b, a)
end
 
ColorPickerFrame.hasOpacity = self.HasAlpha
ColorPickerFrame.opacityFunc = function()
local r, g, b = ColorPickerFrame:GetColorRGB()
local a = 1 - OpacitySliderFrame:GetValue()
ColorCallback(self, r, g, b, a, true)
end
 
local r, g, b, a = self.r, self.g, self.b, self.a
if self.HasAlpha then
ColorPickerFrame.opacity = 1 - (a or 0)
end
ColorPickerFrame:SetColorRGB(r, g, b)
 
ColorPickerFrame.cancelFunc = function()
ColorCallback(self, r, g, b, a, true)
end
 
ShowUIPanel(ColorPickerFrame)
end
AceGUI:ClearFocus()
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetHeight(24)
self:SetWidth(200)
self:SetHasAlpha(false)
self:SetColor(0, 0, 0, 1)
self:SetDisabled(nil)
self:SetLabel(nil)
end,
 
-- ["OnRelease"] = nil,
 
["SetLabel"] = function(self, text)
self.text:SetText(text)
end,
 
["SetColor"] = function(self, r, g, b, a)
self.r = r
self.g = g
self.b = b
self.a = a or 1
self.colorSwatch:SetVertexColor(r, g, b, a)
end,
 
["SetHasAlpha"] = function(self, HasAlpha)
self.HasAlpha = HasAlpha
end,
 
["SetDisabled"] = function(self, disabled)
self.disabled = disabled
if self.disabled then
self.frame:Disable()
self.text:SetTextColor(0.5, 0.5, 0.5)
else
self.frame:Enable()
self.text:SetTextColor(1, 1, 1)
end
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local function Constructor()
local frame = CreateFrame("Button", nil, UIParent)
frame:Hide()
 
frame:EnableMouse(true)
frame:SetScript("OnEnter", Control_OnEnter)
frame:SetScript("OnLeave", Control_OnLeave)
frame:SetScript("OnClick", ColorSwatch_OnClick)
 
local colorSwatch = frame:CreateTexture(nil, "OVERLAY")
colorSwatch:SetWidth(19)
colorSwatch:SetHeight(19)
colorSwatch:SetTexture("Interface\\ChatFrame\\ChatFrameColorSwatch")
colorSwatch:SetPoint("LEFT")
 
local texture = frame:CreateTexture(nil, "BACKGROUND")
texture:SetWidth(16)
texture:SetHeight(16)
texture:SetTexture(1, 1, 1)
texture:SetPoint("CENTER", colorSwatch)
texture:Show()
 
local checkers = frame:CreateTexture(nil, "BACKGROUND")
checkers:SetWidth(14)
checkers:SetHeight(14)
checkers:SetTexture("Tileset\\Generic\\Checkers")
checkers:SetTexCoord(.25, 0, 0.5, .25)
checkers:SetDesaturated(true)
checkers:SetVertexColor(1, 1, 1, 0.75)
checkers:SetPoint("CENTER", colorSwatch)
checkers:Show()
 
local text = frame:CreateFontString(nil,"OVERLAY","GameFontHighlight")
text:SetHeight(24)
text:SetJustifyH("LEFT")
text:SetTextColor(1, 1, 1)
text:SetPoint("LEFT", colorSwatch, "RIGHT", 2, 0)
text:SetPoint("RIGHT")
 
--local highlight = frame:CreateTexture(nil, "HIGHLIGHT")
--highlight:SetTexture("Interface\\QuestFrame\\UI-QuestTitleHighlight")
--highlight:SetBlendMode("ADD")
--highlight:SetAllPoints(frame)
 
local widget = {
colorSwatch = colorSwatch,
text = text,
frame = frame,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
 
return AceGUI:RegisterAsWidget(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIWidget-InteractiveLabel.lua New file
0,0 → 1,101
--[[-----------------------------------------------------------------------------
InteractiveLabel Widget
-------------------------------------------------------------------------------]]
local Type, Version = "InteractiveLabel", 20
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local select, pairs = select, pairs
 
-- WoW APIs
local CreateFrame, UIParent = CreateFrame, UIParent
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: GameFontHighlightSmall
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function Control_OnEnter(frame)
frame.obj:Fire("OnEnter")
end
 
local function Control_OnLeave(frame)
frame.obj:Fire("OnLeave")
end
 
local function Label_OnClick(frame, button)
frame.obj:Fire("OnClick", button)
AceGUI:ClearFocus()
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:LabelOnAcquire()
self:SetHighlight()
self:SetHighlightTexCoord()
self:SetDisabled(false)
end,
 
-- ["OnRelease"] = nil,
 
["SetHighlight"] = function(self, ...)
self.highlight:SetTexture(...)
end,
 
["SetHighlightTexCoord"] = function(self, ...)
local c = select("#", ...)
if c == 4 or c == 8 then
self.highlight:SetTexCoord(...)
else
self.highlight:SetTexCoord(0, 1, 0, 1)
end
end,
 
["SetDisabled"] = function(self,disabled)
self.disabled = disabled
if disabled then
self.frame:EnableMouse(false)
self.label:SetTextColor(0.5, 0.5, 0.5)
else
self.frame:EnableMouse(true)
self.label:SetTextColor(1, 1, 1)
end
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local function Constructor()
-- create a Label type that we will hijack
local label = AceGUI:Create("Label")
 
local frame = label.frame
frame:EnableMouse(true)
frame:SetScript("OnEnter", Control_OnEnter)
frame:SetScript("OnLeave", Control_OnLeave)
frame:SetScript("OnMouseDown", Label_OnClick)
 
local highlight = frame:CreateTexture(nil, "HIGHLIGHT")
highlight:SetTexture(nil)
highlight:SetAllPoints()
highlight:SetBlendMode("ADD")
 
label.highlight = highlight
label.type = Type
label.LabelOnAcquire = label.OnAcquire
for method, func in pairs(methods) do
label[method] = func
end
 
return label
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
 
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIWidget-Label.lua New file
0,0 → 1,162
--[[-----------------------------------------------------------------------------
Label Widget
Displays text and optionally an icon.
-------------------------------------------------------------------------------]]
local Type, Version = "Label", 21
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local max, select, pairs = math.max, select, pairs
 
-- WoW APIs
local CreateFrame, UIParent = CreateFrame, UIParent
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: GameFontHighlightSmall
 
--[[-----------------------------------------------------------------------------
Support functions
-------------------------------------------------------------------------------]]
 
local function UpdateImageAnchor(self)
if self.resizing then return end
local frame = self.frame
local width = frame.width or frame:GetWidth() or 0
local image = self.image
local label = self.label
local height
 
label:ClearAllPoints()
image:ClearAllPoints()
 
if self.imageshown then
local imagewidth = image:GetWidth()
if (width - imagewidth) < 200 or (label:GetText() or "") == "" then
-- image goes on top centered when less than 200 width for the text, or if there is no text
image:SetPoint("TOP")
label:SetPoint("TOP", image, "BOTTOM")
label:SetPoint("LEFT")
label:SetWidth(width)
height = image:GetHeight() + label:GetHeight()
else
-- image on the left
image:SetPoint("TOPLEFT")
label:SetPoint("TOPLEFT", image, "TOPRIGHT", 4, 0)
label:SetWidth(width - imagewidth - 4)
height = max(image:GetHeight(), label:GetHeight())
end
else
-- no image shown
label:SetPoint("TOPLEFT")
label:SetWidth(width)
height = label:GetHeight()
end
 
self.resizing = true
frame:SetHeight(height)
frame.height = height
self.resizing = nil
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
-- set the flag to stop constant size updates
self.resizing = true
-- height is set dynamically by the text and image size
self:SetWidth(200)
self:SetText()
self:SetImage(nil)
self:SetImageSize(16, 16)
self:SetColor()
self:SetFontObject()
 
-- reset the flag
self.resizing = nil
-- run the update explicitly
UpdateImageAnchor(self)
end,
 
-- ["OnRelease"] = nil,
 
["OnWidthSet"] = function(self, width)
UpdateImageAnchor(self)
end,
 
["SetText"] = function(self, text)
self.label:SetText(text)
UpdateImageAnchor(self)
end,
 
["SetColor"] = function(self, r, g, b)
if not (r and g and b) then
r, g, b = 1, 1, 1
end
self.label:SetVertexColor(r, g, b)
end,
 
["SetImage"] = function(self, path, ...)
local image = self.image
image:SetTexture(path)
 
if image:GetTexture() then
self.imageshown = true
local n = select("#", ...)
if n == 4 or n == 8 then
image:SetTexCoord(...)
else
image:SetTexCoord(0, 1, 0, 1)
end
else
self.imageshown = nil
end
UpdateImageAnchor(self)
end,
 
["SetFont"] = function(self, font, height, flags)
self.label:SetFont(font, height, flags)
end,
 
["SetFontObject"] = function(self, font)
self:SetFont((font or GameFontHighlightSmall):GetFont())
end,
 
["SetImageSize"] = function(self, width, height)
self.image:SetWidth(width)
self.image:SetHeight(height)
UpdateImageAnchor(self)
end,
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local function Constructor()
local frame = CreateFrame("Frame", nil, UIParent)
frame:Hide()
 
local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontHighlightSmall")
label:SetJustifyH("LEFT")
label:SetJustifyV("TOP")
 
local image = frame:CreateTexture(nil, "BACKGROUND")
 
-- create widget
local widget = {
label = label,
image = image,
frame = frame,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
 
return AceGUI:RegisterAsWidget(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIWidget-MultiLineEditBox.lua New file
0,0 → 1,308
local Type, Version = "MultiLineEditBox", 24
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local pairs = pairs
 
-- WoW APIs
local GetCursorInfo, GetSpellInfo, ClearCursor = GetCursorInfo, GetSpellInfo, ClearCursor
local CreateFrame, UIParent = CreateFrame, UIParent
local _G = _G
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: ACCEPT, ChatFontNormal
 
--[[-----------------------------------------------------------------------------
Support functions
-------------------------------------------------------------------------------]]
local function Layout(self)
self:SetHeight(self.numlines * 14 + (self.disablebutton and 19 or 41) + self.labelHeight)
 
if self.labelHeight == 0 then
self.scrollBar:SetPoint("TOP", self.frame, "TOP", 0, -23)
else
self.scrollBar:SetPoint("TOP", self.label, "BOTTOM", 0, -19)
end
 
if self.disablebutton then
self.scrollBar:SetPoint("BOTTOM", self.frame, "BOTTOM", 0, 21)
self.scrollBG:SetPoint("BOTTOMLEFT", 0, 4)
else
self.scrollBar:SetPoint("BOTTOM", self.button, "TOP", 0, 18)
self.scrollBG:SetPoint("BOTTOMLEFT", self.button, "TOPLEFT")
end
end
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function OnClick(self) -- Button
self = self.obj
self.editBox:ClearFocus()
if not self:Fire("OnEnterPressed", self.editBox:GetText()) then
self.button:Disable()
end
end
 
local function OnCursorChanged(self, _, y, _, cursorHeight) -- EditBox
self, y = self.obj.scrollFrame, -y
local offset = self:GetVerticalScroll()
if y < offset then
self:SetVerticalScroll(y)
else
y = y + cursorHeight - self:GetHeight()
if y > offset then
self:SetVerticalScroll(y)
end
end
end
 
local function OnEditFocusLost(self) -- EditBox
self:HighlightText(0, 0)
end
 
local function OnEnter(self) -- EditBox / ScrollFrame
self = self.obj
if not self.entered then
self.entered = true
self:Fire("OnEnter")
end
end
 
local function OnLeave(self) -- EditBox / ScrollFrame
self = self.obj
if self.entered then
self.entered = nil
self:Fire("OnLeave")
end
end
 
local function OnMouseUp(self) -- ScrollFrame
self = self.obj.editBox
self:SetFocus()
self:SetCursorPosition(self:GetNumLetters())
end
 
local function OnReceiveDrag(self) -- EditBox / ScrollFrame
local type, id, info = GetCursorInfo()
if type == "spell" then
info = GetSpellInfo(id, info)
elseif type ~= "item" then
return
end
ClearCursor()
self = self.obj
local editBox = self.editBox
if not editBox:HasFocus() then
editBox:SetFocus()
editBox:SetCursorPosition(editBox:GetNumLetters())
end
editBox:Insert(info)
self.button:Enable()
end
 
local function OnSizeChanged(self, width, height) -- ScrollFrame
self.obj.editBox:SetWidth(width)
end
 
local function OnTextChanged(self, userInput) -- EditBox
if userInput then
self = self.obj
self:Fire("OnTextChanged", self.editBox:GetText())
self.button:Enable()
end
end
 
local function OnTextSet(self) -- EditBox
self:HighlightText(0, 0)
self:SetCursorPosition(self:GetNumLetters())
self:SetCursorPosition(0)
self.obj.button:Disable()
end
 
local function OnVerticalScroll(self, offset) -- ScrollFrame
local editBox = self.obj.editBox
editBox:SetHitRectInsets(0, 0, offset, editBox:GetHeight() - offset - self:GetHeight())
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self.editBox:SetText("")
self:SetDisabled(false)
self:SetWidth(200)
self:DisableButton(false)
self:SetNumLines()
self.entered = nil
self:SetMaxLetters(0)
end,
 
-- ["OnRelease"] = nil,
 
["SetDisabled"] = function(self, disabled)
local editBox = self.editBox
if disabled then
editBox:ClearFocus()
editBox:EnableMouse(false)
editBox:SetTextColor(0.5, 0.5, 0.5)
self.label:SetTextColor(0.5, 0.5, 0.5)
self.scrollFrame:EnableMouse(false)
self.button:Disable()
else
editBox:EnableMouse(true)
editBox:SetTextColor(1, 1, 1)
self.label:SetTextColor(1, 0.82, 0)
self.scrollFrame:EnableMouse(true)
end
end,
 
["SetLabel"] = function(self, text)
if text and text ~= "" then
self.label:SetText(text)
if self.labelHeight ~= 10 then
self.labelHeight = 10
self.label:Show()
end
elseif self.labelHeight ~= 0 then
self.labelHeight = 0
self.label:Hide()
end
Layout(self)
end,
 
["SetNumLines"] = function(self, value)
if not value or value < 4 then
value = 4
end
self.numlines = value
Layout(self)
end,
 
["SetText"] = function(self, text)
self.editBox:SetText(text)
end,
 
["GetText"] = function(self)
return self.editBox:GetText()
end,
 
["SetMaxLetters"] = function (self, num)
self.editBox:SetMaxLetters(num or 0)
end,
 
["DisableButton"] = function(self, disabled)
self.disablebutton = disabled
if disabled then
self.button:Hide()
else
self.button:Show()
end
Layout(self)
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local backdrop = {
bgFile = [[Interface\Tooltips\UI-Tooltip-Background]],
edgeFile = [[Interface\Tooltips\UI-Tooltip-Border]], edgeSize = 16,
insets = { left = 4, right = 3, top = 4, bottom = 3 }
}
 
local function Constructor()
local frame = CreateFrame("Frame", nil, UIParent)
frame:Hide()
 
local widgetNum = AceGUI:GetNextWidgetNum(Type)
 
local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
label:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, -4)
label:SetPoint("TOPRIGHT", frame, "TOPRIGHT", 0, -4)
label:SetJustifyH("LEFT")
label:SetText(ACCEPT)
label:SetHeight(10)
 
local button = CreateFrame("Button", ("%s%dButton"):format(Type, widgetNum), frame, "UIPanelButtonTemplate2")
button:SetPoint("BOTTOMLEFT", 0, 4)
button:SetHeight(22)
button:SetWidth(label:GetStringWidth() + 24)
button:SetText(ACCEPT)
button:SetScript("OnClick", OnClick)
button:Disable()
 
local text = button:GetFontString()
text:ClearAllPoints()
text:SetPoint("TOPLEFT", button, "TOPLEFT", 5, -5)
text:SetPoint("BOTTOMRIGHT", button, "BOTTOMRIGHT", -5, 1)
text:SetJustifyV("MIDDLE")
 
local scrollBG = CreateFrame("Frame", nil, frame)
scrollBG:SetBackdrop(backdrop)
scrollBG:SetBackdropColor(0, 0, 0)
scrollBG:SetBackdropBorderColor(0.4, 0.4, 0.4)
 
local scrollFrame = CreateFrame("ScrollFrame", ("%s%dScrollFrame"):format(Type, widgetNum), frame, "UIPanelScrollFrameTemplate")
 
local scrollBar = _G[scrollFrame:GetName() .. "ScrollBar"]
scrollBar:ClearAllPoints()
scrollBar:SetPoint("TOP", label, "BOTTOM", 0, -19)
scrollBar:SetPoint("BOTTOM", button, "TOP", 0, 18)
scrollBar:SetPoint("RIGHT", frame, "RIGHT")
 
scrollBG:SetPoint("TOPRIGHT", scrollBar, "TOPLEFT", 0, 19)
scrollBG:SetPoint("BOTTOMLEFT", button, "TOPLEFT")
 
scrollFrame:SetPoint("TOPLEFT", scrollBG, "TOPLEFT", 5, -6)
scrollFrame:SetPoint("BOTTOMRIGHT", scrollBG, "BOTTOMRIGHT", -4, 4)
scrollFrame:SetScript("OnEnter", OnEnter)
scrollFrame:SetScript("OnLeave", OnLeave)
scrollFrame:SetScript("OnMouseUp", OnMouseUp)
scrollFrame:SetScript("OnReceiveDrag", OnReceiveDrag)
scrollFrame:SetScript("OnSizeChanged", OnSizeChanged)
scrollFrame:HookScript("OnVerticalScroll", OnVerticalScroll)
 
local editBox = CreateFrame("EditBox", nil, scrollFrame)
editBox:SetAllPoints()
editBox:SetFontObject(ChatFontNormal)
editBox:SetMultiLine(true)
editBox:EnableMouse(true)
editBox:SetAutoFocus(false)
editBox:SetCountInvisibleLetters(false)
editBox:SetScript("OnCursorChanged", OnCursorChanged)
editBox:SetScript("OnEditFocusLost", OnEditFocusLost)
editBox:SetScript("OnEnter", OnEnter)
editBox:SetScript("OnEscapePressed", editBox.ClearFocus)
editBox:SetScript("OnLeave", OnLeave)
editBox:SetScript("OnMouseDown", OnReceiveDrag)
editBox:SetScript("OnReceiveDrag", OnReceiveDrag)
editBox:SetScript("OnTextChanged", OnTextChanged)
editBox:SetScript("OnTextSet", OnTextSet)
 
scrollFrame:SetScrollChild(editBox)
 
local widget = {
button = button,
editBox = editBox,
frame = frame,
label = label,
labelHeight = 10,
numlines = 4,
scrollBar = scrollBar,
scrollBG = scrollBG,
scrollFrame = scrollFrame,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
button.obj, editBox.obj, scrollFrame.obj = widget, widget, widget
 
return AceGUI:RegisterAsWidget(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIWidget-Slider.lua New file
0,0 → 1,281
--[[-----------------------------------------------------------------------------
Slider Widget
Graphical Slider, like, for Range values.
-------------------------------------------------------------------------------]]
local Type, Version = "Slider", 20
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local min, max, floor = math.min, math.max, math.floor
local tonumber, pairs = tonumber, pairs
 
-- WoW APIs
local PlaySound = PlaySound
local CreateFrame, UIParent = CreateFrame, UIParent
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: GameFontHighlightSmall
 
--[[-----------------------------------------------------------------------------
Support functions
-------------------------------------------------------------------------------]]
local function UpdateText(self)
local value = self.value or 0
if self.ispercent then
self.editbox:SetText(("%s%%"):format(floor(value * 1000 + 0.5) / 10))
else
self.editbox:SetText(floor(value * 100 + 0.5) / 100)
end
end
 
local function UpdateLabels(self)
local min, max = (self.min or 0), (self.max or 100)
if self.ispercent then
self.lowtext:SetFormattedText("%s%%", (min * 100))
self.hightext:SetFormattedText("%s%%", (max * 100))
else
self.lowtext:SetText(min)
self.hightext:SetText(max)
end
end
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function Control_OnEnter(frame)
frame.obj:Fire("OnEnter")
end
 
local function Control_OnLeave(frame)
frame.obj:Fire("OnLeave")
end
 
local function Frame_OnMouseDown(frame)
frame.obj.slider:EnableMouseWheel(true)
AceGUI:ClearFocus()
end
 
local function Slider_OnValueChanged(frame)
local self = frame.obj
if not frame.setup then
local newvalue = frame:GetValue()
if newvalue ~= self.value and not self.disabled then
self.value = newvalue
self:Fire("OnValueChanged", newvalue)
end
if self.value then
UpdateText(self)
end
end
end
 
local function Slider_OnMouseUp(frame)
local self = frame.obj
self:Fire("OnMouseUp", self.value)
end
 
local function Slider_OnMouseWheel(frame, v)
local self = frame.obj
if not self.disabled then
local value = self.value
if v > 0 then
value = min(value + (self.step or 1), self.max)
else
value = max(value - (self.step or 1), self.min)
end
self.slider:SetValue(value)
end
end
 
local function EditBox_OnEscapePressed(frame)
frame:ClearFocus()
end
 
local function EditBox_OnEnterPressed(frame)
local self = frame.obj
local value = frame:GetText()
if self.ispercent then
value = value:gsub('%%', '')
value = tonumber(value) / 100
else
value = tonumber(value)
end
 
if value then
PlaySound("igMainMenuOptionCheckBoxOn")
self.slider:SetValue(value)
self:Fire("OnMouseUp", value)
end
end
 
local function EditBox_OnEnter(frame)
frame:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)
end
 
local function EditBox_OnLeave(frame)
frame:SetBackdropBorderColor(0.3, 0.3, 0.3, 0.8)
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetWidth(200)
self:SetHeight(44)
self:SetDisabled(false)
self:SetIsPercent(nil)
self:SetSliderValues(0,100,1)
self:SetValue(0)
self.slider:EnableMouseWheel(false)
end,
 
-- ["OnRelease"] = nil,
 
["SetDisabled"] = function(self, disabled)
self.disabled = disabled
if disabled then
self.slider:EnableMouse(false)
self.label:SetTextColor(.5, .5, .5)
self.hightext:SetTextColor(.5, .5, .5)
self.lowtext:SetTextColor(.5, .5, .5)
--self.valuetext:SetTextColor(.5, .5, .5)
self.editbox:SetTextColor(.5, .5, .5)
self.editbox:EnableMouse(false)
self.editbox:ClearFocus()
else
self.slider:EnableMouse(true)
self.label:SetTextColor(1, .82, 0)
self.hightext:SetTextColor(1, 1, 1)
self.lowtext:SetTextColor(1, 1, 1)
--self.valuetext:SetTextColor(1, 1, 1)
self.editbox:SetTextColor(1, 1, 1)
self.editbox:EnableMouse(true)
end
end,
 
["SetValue"] = function(self, value)
self.slider.setup = true
self.slider:SetValue(value)
self.value = value
UpdateText(self)
self.slider.setup = nil
end,
 
["GetValue"] = function(self)
return self.value
end,
 
["SetLabel"] = function(self, text)
self.label:SetText(text)
end,
 
["SetSliderValues"] = function(self, min, max, step)
local frame = self.slider
frame.setup = true
self.min = min
self.max = max
self.step = step
frame:SetMinMaxValues(min or 0,max or 100)
UpdateLabels(self)
frame:SetValueStep(step or 1)
if self.value then
frame:SetValue(self.value)
end
frame.setup = nil
end,
 
["SetIsPercent"] = function(self, value)
self.ispercent = value
UpdateLabels(self)
UpdateText(self)
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local SliderBackdrop = {
bgFile = "Interface\\Buttons\\UI-SliderBar-Background",
edgeFile = "Interface\\Buttons\\UI-SliderBar-Border",
tile = true, tileSize = 8, edgeSize = 8,
insets = { left = 3, right = 3, top = 6, bottom = 6 }
}
 
local ManualBackdrop = {
bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
edgeFile = "Interface\\ChatFrame\\ChatFrameBackground",
tile = true, edgeSize = 1, tileSize = 5,
}
 
local function Constructor()
local frame = CreateFrame("Frame", nil, UIParent)
 
frame:EnableMouse(true)
frame:SetScript("OnMouseDown", Frame_OnMouseDown)
 
local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
label:SetPoint("TOPLEFT")
label:SetPoint("TOPRIGHT")
label:SetJustifyH("CENTER")
label:SetHeight(15)
 
local slider = CreateFrame("Slider", nil, frame)
slider:SetOrientation("HORIZONTAL")
slider:SetHeight(15)
slider:SetHitRectInsets(0, 0, -10, 0)
slider:SetBackdrop(SliderBackdrop)
slider:SetThumbTexture("Interface\\Buttons\\UI-SliderBar-Button-Horizontal")
slider:SetPoint("TOP", label, "BOTTOM")
slider:SetPoint("LEFT", 3, 0)
slider:SetPoint("RIGHT", -3, 0)
slider:SetValue(0)
slider:SetScript("OnValueChanged",Slider_OnValueChanged)
slider:SetScript("OnEnter", Control_OnEnter)
slider:SetScript("OnLeave", Control_OnLeave)
slider:SetScript("OnMouseUp", Slider_OnMouseUp)
slider:SetScript("OnMouseWheel", Slider_OnMouseWheel)
 
local lowtext = slider:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
lowtext:SetPoint("TOPLEFT", slider, "BOTTOMLEFT", 2, 3)
 
local hightext = slider:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
hightext:SetPoint("TOPRIGHT", slider, "BOTTOMRIGHT", -2, 3)
 
local editbox = CreateFrame("EditBox", nil, frame)
editbox:SetAutoFocus(false)
editbox:SetFontObject(GameFontHighlightSmall)
editbox:SetPoint("TOP", slider, "BOTTOM")
editbox:SetHeight(14)
editbox:SetWidth(70)
editbox:SetJustifyH("CENTER")
editbox:EnableMouse(true)
editbox:SetBackdrop(ManualBackdrop)
editbox:SetBackdropColor(0, 0, 0, 0.5)
editbox:SetBackdropBorderColor(0.3, 0.3, 0.30, 0.80)
editbox:SetScript("OnEnter", EditBox_OnEnter)
editbox:SetScript("OnLeave", EditBox_OnLeave)
editbox:SetScript("OnEnterPressed", EditBox_OnEnterPressed)
editbox:SetScript("OnEscapePressed", EditBox_OnEscapePressed)
 
local widget = {
label = label,
slider = slider,
lowtext = lowtext,
hightext = hightext,
editbox = editbox,
alignoffset = 25,
frame = frame,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
slider.obj, editbox.obj = widget, widget
 
return AceGUI:RegisterAsWidget(widget)
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIContainer-TabGroup.lua New file
0,0 → 1,348
--[[-----------------------------------------------------------------------------
TabGroup Container
Container that uses tabs on top to switch between groups.
-------------------------------------------------------------------------------]]
local Type, Version = "TabGroup", 30
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local pairs, ipairs, assert, type, wipe = pairs, ipairs, assert, type, wipe
 
-- WoW APIs
local PlaySound = PlaySound
local CreateFrame, UIParent = CreateFrame, UIParent
local _G = _G
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: PanelTemplates_TabResize, PanelTemplates_SetDisabledTabState, PanelTemplates_SelectTab, PanelTemplates_DeselectTab
 
-- local upvalue storage used by BuildTabs
local widths = {}
local rowwidths = {}
local rowends = {}
 
--[[-----------------------------------------------------------------------------
Support functions
-------------------------------------------------------------------------------]]
local function UpdateTabLook(frame)
if frame.disabled then
PanelTemplates_SetDisabledTabState(frame)
elseif frame.selected then
PanelTemplates_SelectTab(frame)
else
PanelTemplates_DeselectTab(frame)
end
end
 
local function Tab_SetText(frame, text)
frame:_SetText(text)
local width = frame.obj.frame.width or frame.obj.frame:GetWidth() or 0
PanelTemplates_TabResize(frame, 0, nil, width)
end
 
local function Tab_SetSelected(frame, selected)
frame.selected = selected
UpdateTabLook(frame)
end
 
local function Tab_SetDisabled(frame, disabled)
frame.disabled = disabled
UpdateTabLook(frame)
end
 
local function BuildTabsOnUpdate(frame)
local self = frame.obj
self:BuildTabs()
frame:SetScript("OnUpdate", nil)
end
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function Tab_OnClick(frame)
if not (frame.selected or frame.disabled) then
PlaySound("igCharacterInfoTab")
frame.obj:SelectTab(frame.value)
end
end
 
local function Tab_OnEnter(frame)
local self = frame.obj
self:Fire("OnTabEnter", self.tabs[frame.id].value, frame)
end
 
local function Tab_OnLeave(frame)
local self = frame.obj
self:Fire("OnTabLeave", self.tabs[frame.id].value, frame)
end
 
local function Tab_OnShow(frame)
_G[frame:GetName().."HighlightTexture"]:SetWidth(frame:GetTextWidth() + 30)
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetTitle()
end,
 
["OnRelease"] = function(self)
self.status = nil
for k in pairs(self.localstatus) do
self.localstatus[k] = nil
end
self.tablist = nil
for _, tab in pairs(self.tabs) do
tab:Hide()
end
end,
 
["CreateTab"] = function(self, id)
local tabname = ("AceGUITabGroup%dTab%d"):format(self.num, id)
local tab = CreateFrame("Button", tabname, self.border, "OptionsFrameTabButtonTemplate")
tab.obj = self
tab.id = id
 
tab.text = _G[tabname .. "Text"]
tab.text:ClearAllPoints()
tab.text:SetPoint("LEFT", 14, -3)
tab.text:SetPoint("RIGHT", -12, -3)
 
tab:SetScript("OnClick", Tab_OnClick)
tab:SetScript("OnEnter", Tab_OnEnter)
tab:SetScript("OnLeave", Tab_OnLeave)
tab:SetScript("OnShow", Tab_OnShow)
 
tab._SetText = tab.SetText
tab.SetText = Tab_SetText
tab.SetSelected = Tab_SetSelected
tab.SetDisabled = Tab_SetDisabled
 
return tab
end,
 
["SetTitle"] = function(self, text)
self.titletext:SetText(text or "")
if text and text ~= "" then
self.alignoffset = 25
else
self.alignoffset = 18
end
self:BuildTabs()
end,
 
["SetStatusTable"] = function(self, status)
assert(type(status) == "table")
self.status = status
end,
 
["SelectTab"] = function(self, value)
local status = self.status or self.localstatus
local found
for i, v in ipairs(self.tabs) do
if v.value == value then
v:SetSelected(true)
found = true
else
v:SetSelected(false)
end
end
status.selected = value
if found then
self:Fire("OnGroupSelected",value)
end
end,
 
["SetTabs"] = function(self, tabs)
self.tablist = tabs
self:BuildTabs()
end,
 
 
["BuildTabs"] = function(self)
local hastitle = (self.titletext:GetText() and self.titletext:GetText() ~= "")
local status = self.status or self.localstatus
local tablist = self.tablist
local tabs = self.tabs
 
if not tablist then return end
 
local width = self.frame.width or self.frame:GetWidth() or 0
 
wipe(widths)
wipe(rowwidths)
wipe(rowends)
 
--Place Text into tabs and get thier initial width
for i, v in ipairs(tablist) do
local tab = tabs[i]
if not tab then
tab = self:CreateTab(i)
tabs[i] = tab
end
 
tab:Show()
tab:SetText(v.text)
tab:SetDisabled(v.disabled)
tab.value = v.value
 
widths[i] = tab:GetWidth() - 6 --tabs are anchored 10 pixels from the right side of the previous one to reduce spacing, but add a fixed 4px padding for the text
end
 
for i = (#tablist)+1, #tabs, 1 do
tabs[i]:Hide()
end
 
--First pass, find the minimum number of rows needed to hold all tabs and the initial tab layout
local numtabs = #tablist
local numrows = 1
local usedwidth = 0
 
for i = 1, #tablist do
--If this is not the first tab of a row and there isn't room for it
if usedwidth ~= 0 and (width - usedwidth - widths[i]) < 0 then
rowwidths[numrows] = usedwidth + 10 --first tab in each row takes up an extra 10px
rowends[numrows] = i - 1
numrows = numrows + 1
usedwidth = 0
end
usedwidth = usedwidth + widths[i]
end
rowwidths[numrows] = usedwidth + 10 --first tab in each row takes up an extra 10px
rowends[numrows] = #tablist
 
--Fix for single tabs being left on the last row, move a tab from the row above if applicable
if numrows > 1 then
--if the last row has only one tab
if rowends[numrows-1] == numtabs-1 then
--if there are more than 2 tabs in the 2nd last row
if (numrows == 2 and rowends[numrows-1] > 2) or (rowends[numrows] - rowends[numrows-1] > 2) then
--move 1 tab from the second last row to the last, if there is enough space
if (rowwidths[numrows] + widths[numtabs-1]) <= width then
rowends[numrows-1] = rowends[numrows-1] - 1
rowwidths[numrows] = rowwidths[numrows] + widths[numtabs-1]
rowwidths[numrows-1] = rowwidths[numrows-1] - widths[numtabs-1]
end
end
end
end
 
--anchor the rows as defined and resize tabs to fill thier row
local starttab = 1
for row, endtab in ipairs(rowends) do
local first = true
for tabno = starttab, endtab do
local tab = tabs[tabno]
tab:ClearAllPoints()
if first then
tab:SetPoint("TOPLEFT", self.frame, "TOPLEFT", 0, -(hastitle and 14 or 7)-(row-1)*20 )
first = false
else
tab:SetPoint("LEFT", tabs[tabno-1], "RIGHT", -10, 0)
end
end
 
-- equal padding for each tab to fill the available width,
-- if the used space is above 75% already
local padding = 0
if not (numrows == 1 and rowwidths[1] < width*0.75) then
padding = (width - rowwidths[row]) / (endtab - starttab+1)
end
 
for i = starttab, endtab do
PanelTemplates_TabResize(tabs[i], padding + 4, nil, width)
end
starttab = endtab + 1
end
 
self.borderoffset = (hastitle and 17 or 10)+((numrows)*20)
self.border:SetPoint("TOPLEFT", 1, -self.borderoffset)
end,
 
["OnWidthSet"] = function(self, width)
local content = self.content
local contentwidth = width - 60
if contentwidth < 0 then
contentwidth = 0
end
content:SetWidth(contentwidth)
content.width = contentwidth
self:BuildTabs(self)
self.frame:SetScript("OnUpdate", BuildTabsOnUpdate)
end,
 
["OnHeightSet"] = function(self, height)
local content = self.content
local contentheight = height - (self.borderoffset + 23)
if contentheight < 0 then
contentheight = 0
end
content:SetHeight(contentheight)
content.height = contentheight
end,
 
["LayoutFinished"] = function(self, width, height)
if self.noAutoHeight then return end
self:SetHeight((height or 0) + (self.borderoffset + 23))
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local PaneBackdrop = {
bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
tile = true, tileSize = 16, edgeSize = 16,
insets = { left = 3, right = 3, top = 5, bottom = 3 }
}
 
local function Constructor()
local num = AceGUI:GetNextWidgetNum(Type)
local frame = CreateFrame("Frame",nil,UIParent)
frame:SetHeight(100)
frame:SetWidth(100)
frame:SetFrameStrata("FULLSCREEN_DIALOG")
 
local titletext = frame:CreateFontString(nil,"OVERLAY","GameFontNormal")
titletext:SetPoint("TOPLEFT", 14, 0)
titletext:SetPoint("TOPRIGHT", -14, 0)
titletext:SetJustifyH("LEFT")
titletext:SetHeight(18)
titletext:SetText("")
 
local border = CreateFrame("Frame", nil, frame)
border:SetPoint("TOPLEFT", 1, -27)
border:SetPoint("BOTTOMRIGHT", -1, 3)
border:SetBackdrop(PaneBackdrop)
border:SetBackdropColor(0.1, 0.1, 0.1, 0.5)
border:SetBackdropBorderColor(0.4, 0.4, 0.4)
 
local content = CreateFrame("Frame", nil, border)
content:SetPoint("TOPLEFT", 10, -7)
content:SetPoint("BOTTOMRIGHT", -10, 7)
 
local widget = {
num = num,
frame = frame,
localstatus = {},
alignoffset = 18,
titletext = titletext,
border = border,
borderoffset = 27,
tabs = {},
content = content,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
 
return AceGUI:RegisterAsContainer(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIWidget-Keybinding.lua New file
0,0 → 1,232
--[[-----------------------------------------------------------------------------
Keybinding Widget
Set Keybindings in the Config UI.
-------------------------------------------------------------------------------]]
local Type, Version = "Keybinding", 22
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local pairs = pairs
 
-- WoW APIs
local IsShiftKeyDown, IsControlKeyDown, IsAltKeyDown = IsShiftKeyDown, IsControlKeyDown, IsAltKeyDown
local CreateFrame, UIParent = CreateFrame, UIParent
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: NOT_BOUND
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
 
local function Control_OnEnter(frame)
frame.obj:Fire("OnEnter")
end
 
local function Control_OnLeave(frame)
frame.obj:Fire("OnLeave")
end
 
local function Keybinding_OnClick(frame, button)
if button == "LeftButton" or button == "RightButton" then
local self = frame.obj
if self.waitingForKey then
frame:EnableKeyboard(false)
self.msgframe:Hide()
frame:UnlockHighlight()
self.waitingForKey = nil
else
frame:EnableKeyboard(true)
self.msgframe:Show()
frame:LockHighlight()
self.waitingForKey = true
end
end
AceGUI:ClearFocus()
end
 
local ignoreKeys = {
["BUTTON1"] = true, ["BUTTON2"] = true,
["UNKNOWN"] = true,
["LSHIFT"] = true, ["LCTRL"] = true, ["LALT"] = true,
["RSHIFT"] = true, ["RCTRL"] = true, ["RALT"] = true,
}
local function Keybinding_OnKeyDown(frame, key)
local self = frame.obj
if self.waitingForKey then
local keyPressed = key
if keyPressed == "ESCAPE" then
keyPressed = ""
else
if ignoreKeys[keyPressed] then return end
if IsShiftKeyDown() then
keyPressed = "SHIFT-"..keyPressed
end
if IsControlKeyDown() then
keyPressed = "CTRL-"..keyPressed
end
if IsAltKeyDown() then
keyPressed = "ALT-"..keyPressed
end
end
 
frame:EnableKeyboard(false)
self.msgframe:Hide()
frame:UnlockHighlight()
self.waitingForKey = nil
 
if not self.disabled then
self:SetKey(keyPressed)
self:Fire("OnKeyChanged", keyPressed)
end
end
end
 
local function Keybinding_OnMouseDown(frame, button)
if button == "LeftButton" or button == "RightButton" then
return
elseif button == "MiddleButton" then
button = "BUTTON3"
elseif button == "Button4" then
button = "BUTTON4"
elseif button == "Button5" then
button = "BUTTON5"
end
Keybinding_OnKeyDown(frame, button)
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetWidth(200)
self:SetLabel("")
self:SetKey("")
self.waitingForKey = nil
self.msgframe:Hide()
self:SetDisabled(false)
self.button:EnableKeyboard(false)
end,
 
-- ["OnRelease"] = nil,
 
["SetDisabled"] = function(self, disabled)
self.disabled = disabled
if disabled then
self.button:Disable()
self.label:SetTextColor(0.5,0.5,0.5)
else
self.button:Enable()
self.label:SetTextColor(1,1,1)
end
end,
 
["SetKey"] = function(self, key)
if (key or "") == "" then
self.button:SetText(NOT_BOUND)
self.button:SetNormalFontObject("GameFontNormal")
else
self.button:SetText(key)
self.button:SetNormalFontObject("GameFontHighlight")
end
end,
 
["GetKey"] = function(self)
local key = self.button:GetText()
if key == NOT_BOUND then
key = nil
end
return key
end,
 
["SetLabel"] = function(self, label)
self.label:SetText(label or "")
if (label or "") == "" then
self.alignoffset = nil
self:SetHeight(24)
else
self.alignoffset = 30
self:SetHeight(44)
end
end,
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
 
local ControlBackdrop = {
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
tile = true, tileSize = 16, edgeSize = 16,
insets = { left = 3, right = 3, top = 3, bottom = 3 }
}
 
local function keybindingMsgFixWidth(frame)
frame:SetWidth(frame.msg:GetWidth() + 10)
frame:SetScript("OnUpdate", nil)
end
 
local function Constructor()
local name = "AceGUI30KeybindingButton" .. AceGUI:GetNextWidgetNum(Type)
 
local frame = CreateFrame("Frame", nil, UIParent)
local button = CreateFrame("Button", name, frame, "UIPanelButtonTemplate2")
 
button:EnableMouse(true)
button:RegisterForClicks("AnyDown")
button:SetScript("OnEnter", Control_OnEnter)
button:SetScript("OnLeave", Control_OnLeave)
button:SetScript("OnClick", Keybinding_OnClick)
button:SetScript("OnKeyDown", Keybinding_OnKeyDown)
button:SetScript("OnMouseDown", Keybinding_OnMouseDown)
button:SetPoint("BOTTOMLEFT")
button:SetPoint("BOTTOMRIGHT")
button:SetHeight(24)
button:EnableKeyboard(false)
 
local text = button:GetFontString()
text:SetPoint("LEFT", 7, 0)
text:SetPoint("RIGHT", -7, 0)
 
local label = frame:CreateFontString(nil, "OVERLAY", "GameFontHighlight")
label:SetPoint("TOPLEFT")
label:SetPoint("TOPRIGHT")
label:SetJustifyH("CENTER")
label:SetHeight(18)
 
local msgframe = CreateFrame("Frame", nil, UIParent)
msgframe:SetHeight(30)
msgframe:SetBackdrop(ControlBackdrop)
msgframe:SetBackdropColor(0,0,0)
msgframe:SetFrameStrata("FULLSCREEN_DIALOG")
msgframe:SetFrameLevel(1000)
 
local msg = msgframe:CreateFontString(nil, "OVERLAY", "GameFontNormal")
msg:SetText("Press a key to bind, ESC to clear the binding or click the button again to cancel.")
msgframe.msg = msg
msg:SetPoint("TOPLEFT", 5, -5)
msgframe:SetScript("OnUpdate", keybindingMsgFixWidth)
msgframe:SetPoint("BOTTOM", button, "TOP")
msgframe:Hide()
 
local widget = {
button = button,
label = label,
msgframe = msgframe,
frame = frame,
alignoffset = 30,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
button.obj = widget
 
return AceGUI:RegisterAsWidget(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIWidget-CheckBox.lua New file
0,0 → 1,289
--[[-----------------------------------------------------------------------------
Checkbox Widget
-------------------------------------------------------------------------------]]
local Type, Version = "CheckBox", 21
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local select, pairs = select, pairs
 
-- WoW APIs
local PlaySound = PlaySound
local CreateFrame, UIParent = CreateFrame, UIParent
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: SetDesaturation, GameFontHighlight
 
--[[-----------------------------------------------------------------------------
Support functions
-------------------------------------------------------------------------------]]
local function AlignImage(self)
local img = self.image:GetTexture()
self.text:ClearAllPoints()
if not img then
self.text:SetPoint("LEFT", self.checkbg, "RIGHT")
self.text:SetPoint("RIGHT")
else
self.text:SetPoint("LEFT", self.image,"RIGHT", 1, 0)
self.text:SetPoint("RIGHT")
end
end
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function Control_OnEnter(frame)
frame.obj:Fire("OnEnter")
end
 
local function Control_OnLeave(frame)
frame.obj:Fire("OnLeave")
end
 
local function CheckBox_OnMouseDown(frame)
local self = frame.obj
if not self.disabled then
if self.image:GetTexture() then
self.text:SetPoint("LEFT", self.image,"RIGHT", 2, -1)
else
self.text:SetPoint("LEFT", self.checkbg, "RIGHT", 1, -1)
end
end
AceGUI:ClearFocus()
end
 
local function CheckBox_OnMouseUp(frame)
local self = frame.obj
if not self.disabled then
self:ToggleChecked()
 
if self.checked then
PlaySound("igMainMenuOptionCheckBoxOn")
else -- for both nil and false (tristate)
PlaySound("igMainMenuOptionCheckBoxOff")
end
 
self:Fire("OnValueChanged", self.checked)
AlignImage(self)
end
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetType()
self:SetValue(false)
self:SetTriState(nil)
-- height is calculated from the width and required space for the description
self:SetWidth(200)
self:SetImage()
self:SetDisabled(nil)
self:SetDescription(nil)
end,
 
-- ["OnRelease"] = nil,
 
["OnWidthSet"] = function(self, width)
if self.desc then
self.desc:SetWidth(width - 30)
if self.desc:GetText() and self.desc:GetText() ~= "" then
self:SetHeight(28 + self.desc:GetHeight())
end
end
end,
 
["SetDisabled"] = function(self, disabled)
self.disabled = disabled
if disabled then
self.frame:Disable()
self.text:SetTextColor(0.5, 0.5, 0.5)
SetDesaturation(self.check, true)
else
self.frame:Enable()
self.text:SetTextColor(1, 1, 1)
if self.tristate and self.checked == nil then
SetDesaturation(self.check, true)
else
SetDesaturation(self.check, false)
end
end
end,
 
["SetValue"] = function(self,value)
local check = self.check
self.checked = value
if value then
SetDesaturation(self.check, false)
self.check:Show()
else
--Nil is the unknown tristate value
if self.tristate and value == nil then
SetDesaturation(self.check, true)
self.check:Show()
else
SetDesaturation(self.check, false)
self.check:Hide()
end
end
self:SetDisabled(self.disabled)
end,
 
["GetValue"] = function(self)
return self.checked
end,
 
["SetTriState"] = function(self, enabled)
self.tristate = enabled
self:SetValue(self:GetValue())
end,
 
["SetType"] = function(self, type)
local checkbg = self.checkbg
local check = self.check
local highlight = self.highlight
 
local size
if type == "radio" then
size = 16
checkbg:SetTexture("Interface\\Buttons\\UI-RadioButton")
checkbg:SetTexCoord(0, 0.25, 0, 1)
check:SetTexture("Interface\\Buttons\\UI-RadioButton")
check:SetTexCoord(0.25, 0.5, 0, 1)
check:SetBlendMode("ADD")
highlight:SetTexture("Interface\\Buttons\\UI-RadioButton")
highlight:SetTexCoord(0.5, 0.75, 0, 1)
else
size = 24
checkbg:SetTexture("Interface\\Buttons\\UI-CheckBox-Up")
checkbg:SetTexCoord(0, 1, 0, 1)
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check")
check:SetTexCoord(0, 1, 0, 1)
check:SetBlendMode("BLEND")
highlight:SetTexture("Interface\\Buttons\\UI-CheckBox-Highlight")
highlight:SetTexCoord(0, 1, 0, 1)
end
checkbg:SetHeight(size)
checkbg:SetWidth(size)
end,
 
["ToggleChecked"] = function(self)
local value = self:GetValue()
if self.tristate then
--cycle in true, nil, false order
if value then
self:SetValue(nil)
elseif value == nil then
self:SetValue(false)
else
self:SetValue(true)
end
else
self:SetValue(not self:GetValue())
end
end,
 
["SetLabel"] = function(self, label)
self.text:SetText(label)
end,
 
["SetDescription"] = function(self, desc)
if desc then
if not self.desc then
local desc = self.frame:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
desc:ClearAllPoints()
desc:SetPoint("TOPLEFT", self.checkbg, "TOPRIGHT", 5, -21)
desc:SetWidth(self.frame.width - 30)
desc:SetJustifyH("LEFT")
desc:SetJustifyV("TOP")
self.desc = desc
end
self.desc:Show()
--self.text:SetFontObject(GameFontNormal)
self.desc:SetText(desc)
self:SetHeight(28 + self.desc:GetHeight())
else
if self.desc then
self.desc:SetText("")
self.desc:Hide()
end
--self.text:SetFontObject(GameFontHighlight)
self:SetHeight(24)
end
end,
 
["SetImage"] = function(self, path, ...)
local image = self.image
image:SetTexture(path)
 
if image:GetTexture() then
local n = select("#", ...)
if n == 4 or n == 8 then
image:SetTexCoord(...)
else
image:SetTexCoord(0, 1, 0, 1)
end
end
AlignImage(self)
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local function Constructor()
local frame = CreateFrame("Button", nil, UIParent)
frame:Hide()
 
frame:EnableMouse(true)
frame:SetScript("OnEnter", Control_OnEnter)
frame:SetScript("OnLeave", Control_OnLeave)
frame:SetScript("OnMouseDown", CheckBox_OnMouseDown)
frame:SetScript("OnMouseUp", CheckBox_OnMouseUp)
 
local checkbg = frame:CreateTexture(nil, "ARTWORK")
checkbg:SetWidth(24)
checkbg:SetHeight(24)
checkbg:SetPoint("TOPLEFT")
checkbg:SetTexture("Interface\\Buttons\\UI-CheckBox-Up")
 
local check = frame:CreateTexture(nil, "OVERLAY")
check:SetAllPoints(checkbg)
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check")
 
local text = frame:CreateFontString(nil, "OVERLAY", "GameFontHighlight")
text:SetJustifyH("LEFT")
text:SetHeight(18)
text:SetPoint("LEFT", checkbg, "RIGHT")
text:SetPoint("RIGHT")
 
local highlight = frame:CreateTexture(nil, "HIGHLIGHT")
highlight:SetTexture("Interface\\Buttons\\UI-CheckBox-Highlight")
highlight:SetBlendMode("ADD")
highlight:SetAllPoints(checkbg)
 
local image = frame:CreateTexture(nil, "OVERLAY")
image:SetHeight(16)
image:SetWidth(16)
image:SetPoint("LEFT", checkbg, "RIGHT", 1, 0)
 
local widget = {
checkbg = checkbg,
check = check,
text = text,
highlight = highlight,
image = image,
frame = frame,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
 
return AceGUI:RegisterAsWidget(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIWidget-Icon.lua New file
0,0 → 1,144
--[[-----------------------------------------------------------------------------
Icon Widget
-------------------------------------------------------------------------------]]
local Type, Version = "Icon", 20
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local select, pairs, print = select, pairs, print
 
-- WoW APIs
local CreateFrame, UIParent, GetBuildInfo = CreateFrame, UIParent, GetBuildInfo
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function Control_OnEnter(frame)
frame.obj:Fire("OnEnter")
end
 
local function Control_OnLeave(frame)
frame.obj:Fire("OnLeave")
end
 
local function Button_OnClick(frame, button)
frame.obj:Fire("OnClick", button)
AceGUI:ClearFocus()
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetHeight(110)
self:SetWidth(110)
self:SetLabel()
self:SetImage(nil)
self:SetImageSize(64, 64)
self:SetDisabled(false)
end,
 
-- ["OnRelease"] = nil,
 
["SetLabel"] = function(self, text)
if text and text ~= "" then
self.label:Show()
self.label:SetText(text)
self:SetHeight(self.image:GetHeight() + 25)
else
self.label:Hide()
self:SetHeight(self.image:GetHeight() + 10)
end
end,
 
["SetImage"] = function(self, path, ...)
local image = self.image
image:SetTexture(path)
 
if image:GetTexture() then
local n = select("#", ...)
if n == 4 or n == 8 then
image:SetTexCoord(...)
else
image:SetTexCoord(0, 1, 0, 1)
end
end
end,
 
["SetImageSize"] = function(self, width, height)
self.image:SetWidth(width)
self.image:SetHeight(height)
--self.frame:SetWidth(width + 30)
if self.label:IsShown() then
self:SetHeight(height + 25)
else
self:SetHeight(height + 10)
end
end,
 
["SetDisabled"] = function(self, disabled)
self.disabled = disabled
if disabled then
self.frame:Disable()
self.label:SetTextColor(0.5, 0.5, 0.5)
self.image:SetVertexColor(0.5, 0.5, 0.5, 0.5)
else
self.frame:Enable()
self.label:SetTextColor(1, 1, 1)
self.image:SetVertexColor(1, 1, 1)
end
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local function Constructor()
local frame = CreateFrame("Button", nil, UIParent)
frame:Hide()
 
frame:EnableMouse(true)
frame:SetScript("OnEnter", Control_OnEnter)
frame:SetScript("OnLeave", Control_OnLeave)
frame:SetScript("OnClick", Button_OnClick)
 
local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontHighlight")
label:SetPoint("BOTTOMLEFT")
label:SetPoint("BOTTOMRIGHT")
label:SetJustifyH("CENTER")
label:SetJustifyV("TOP")
label:SetHeight(18)
 
local image = frame:CreateTexture(nil, "BACKGROUND")
image:SetWidth(64)
image:SetHeight(64)
image:SetPoint("TOP", 0, -5)
 
local highlight = frame:CreateTexture(nil, "HIGHLIGHT")
highlight:SetAllPoints(image)
highlight:SetTexture("Interface\\PaperDollInfoFrame\\UI-Character-Tab-Highlight")
highlight:SetTexCoord(0, 1, 0.23, 0.77)
highlight:SetBlendMode("ADD")
 
local widget = {
label = label,
image = image,
frame = frame,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
-- SetText is deprecated, but keep it around for a while. (say, to WoW 4.0)
if (select(4, GetBuildInfo()) < 40000) then
widget.SetText = widget.SetLabel
else
widget.SetText = function(self, ...) print("AceGUI-3.0-Icon: SetText is deprecated! Use SetLabel instead!"); self:SetLabel(...) end
end
 
return AceGUI:RegisterAsWidget(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIContainer-BlizOptionsGroup.lua New file
0,0 → 1,133
--[[-----------------------------------------------------------------------------
BlizOptionsGroup Container
Simple container widget for the integration of AceGUI into the Blizzard Interface Options
-------------------------------------------------------------------------------]]
local Type, Version = "BlizOptionsGroup", 20
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local pairs = pairs
 
-- WoW APIs
local CreateFrame = CreateFrame
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
 
local function OnShow(frame)
frame.obj:Fire("OnShow")
end
 
local function OnHide(frame)
frame.obj:Fire("OnHide")
end
 
--[[-----------------------------------------------------------------------------
Support functions
-------------------------------------------------------------------------------]]
 
local function okay(frame)
frame.obj:Fire("okay")
end
 
local function cancel(frame)
frame.obj:Fire("cancel")
end
 
local function defaults(frame)
frame.obj:Fire("defaults")
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
 
local methods = {
["OnAcquire"] = function(self)
self:SetName()
self:SetTitle()
end,
 
-- ["OnRelease"] = nil,
 
["OnWidthSet"] = function(self, width)
local content = self.content
local contentwidth = width - 63
if contentwidth < 0 then
contentwidth = 0
end
content:SetWidth(contentwidth)
content.width = contentwidth
end,
 
["OnHeightSet"] = function(self, height)
local content = self.content
local contentheight = height - 26
if contentheight < 0 then
contentheight = 0
end
content:SetHeight(contentheight)
content.height = contentheight
end,
 
["SetName"] = function(self, name, parent)
self.frame.name = name
self.frame.parent = parent
end,
 
["SetTitle"] = function(self, title)
local content = self.content
content:ClearAllPoints()
if not title or title == "" then
content:SetPoint("TOPLEFT", 10, -10)
self.label:SetText("")
else
content:SetPoint("TOPLEFT", 10, -40)
self.label:SetText(title)
end
content:SetPoint("BOTTOMRIGHT", -10, 10)
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local function Constructor()
local frame = CreateFrame("Frame")
frame:Hide()
 
-- support functions for the Blizzard Interface Options
frame.okay = okay
frame.cancel = cancel
frame.defaults = defaults
 
frame:SetScript("OnHide", OnHide)
frame:SetScript("OnShow", OnShow)
 
local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
label:SetPoint("TOPLEFT", 10, -15)
label:SetPoint("BOTTOMRIGHT", frame, "TOPRIGHT", 10, -45)
label:SetJustifyH("LEFT")
label:SetJustifyV("TOP")
 
--Container Support
local content = CreateFrame("Frame", nil, frame)
content:SetPoint("TOPLEFT", 10, -10)
content:SetPoint("BOTTOMRIGHT", -10, 10)
 
local widget = {
label = label,
frame = frame,
content = content,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
 
return AceGUI:RegisterAsContainer(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIContainer-Frame.lua New file
0,0 → 1,298
--[[-----------------------------------------------------------------------------
Frame Container
-------------------------------------------------------------------------------]]
local Type, Version = "Frame", 21
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local pairs, assert, type = pairs, assert, type
local wipe = table.wipe
 
-- WoW APIs
local PlaySound = PlaySound
local CreateFrame, UIParent = CreateFrame, UIParent
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: CLOSE
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function Button_OnClick(frame)
PlaySound("gsTitleOptionExit")
frame.obj:Hide()
end
 
local function Frame_OnClose(frame)
frame.obj:Fire("OnClose")
end
 
local function Frame_OnMouseDown(frame)
AceGUI:ClearFocus()
end
 
local function Title_OnMouseDown(frame)
frame:GetParent():StartMoving()
AceGUI:ClearFocus()
end
 
local function MoverSizer_OnMouseUp(mover)
local frame = mover:GetParent()
frame:StopMovingOrSizing()
local self = frame.obj
local status = self.status or self.localstatus
status.width = frame:GetWidth()
status.height = frame:GetHeight()
status.top = frame:GetTop()
status.left = frame:GetLeft()
end
 
local function SizerSE_OnMouseDown(frame)
frame:GetParent():StartSizing("BOTTOMRIGHT")
AceGUI:ClearFocus()
end
 
local function SizerS_OnMouseDown(frame)
frame:GetParent():StartSizing("BOTTOM")
AceGUI:ClearFocus()
end
 
local function SizerE_OnMouseDown(frame)
frame:GetParent():StartSizing("RIGHT")
AceGUI:ClearFocus()
end
 
local function StatusBar_OnEnter(frame)
frame.obj:Fire("OnEnterStatusBar")
end
 
local function StatusBar_OnLeave(frame)
frame.obj:Fire("OnLeaveStatusBar")
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self.frame:SetParent(UIParent)
self.frame:SetFrameStrata("FULLSCREEN_DIALOG")
self:SetTitle()
self:SetStatusText()
self:ApplyStatus()
self:Show()
end,
 
["OnRelease"] = function(self)
self.status = nil
wipe(self.localstatus)
end,
 
["OnWidthSet"] = function(self, width)
local content = self.content
local contentwidth = width - 34
if contentwidth < 0 then
contentwidth = 0
end
content:SetWidth(contentwidth)
content.width = contentwidth
end,
 
["OnHeightSet"] = function(self, height)
local content = self.content
local contentheight = height - 57
if contentheight < 0 then
contentheight = 0
end
content:SetHeight(contentheight)
content.height = contentheight
end,
 
["SetTitle"] = function(self, title)
self.titletext:SetText(title)
end,
 
["SetStatusText"] = function(self, text)
self.statustext:SetText(text)
end,
 
["Hide"] = function(self)
self.frame:Hide()
end,
 
["Show"] = function(self)
self.frame:Show()
end,
 
-- called to set an external table to store status in
["SetStatusTable"] = function(self, status)
assert(type(status) == "table")
self.status = status
self:ApplyStatus()
end,
 
["ApplyStatus"] = function(self)
local status = self.status or self.localstatus
local frame = self.frame
self:SetWidth(status.width or 700)
self:SetHeight(status.height or 500)
frame:ClearAllPoints()
if status.top and status.left then
frame:SetPoint("TOP", UIParent, "BOTTOM", 0, status.top)
frame:SetPoint("LEFT", UIParent, "LEFT", status.left, 0)
else
frame:SetPoint("CENTER")
end
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local FrameBackdrop = {
bgFile = "Interface\\DialogFrame\\UI-DialogBox-Background",
edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
tile = true, tileSize = 32, edgeSize = 32,
insets = { left = 8, right = 8, top = 8, bottom = 8 }
}
 
local PaneBackdrop = {
bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
tile = true, tileSize = 16, edgeSize = 16,
insets = { left = 3, right = 3, top = 5, bottom = 3 }
}
 
local function Constructor()
local frame = CreateFrame("Frame", nil, UIParent)
frame:Hide()
 
frame:EnableMouse(true)
frame:SetMovable(true)
frame:SetResizable(true)
frame:SetFrameStrata("FULLSCREEN_DIALOG")
frame:SetBackdrop(FrameBackdrop)
frame:SetBackdropColor(0, 0, 0, 1)
frame:SetMinResize(400, 200)
frame:SetToplevel(true)
frame:SetScript("OnHide", Frame_OnClose)
frame:SetScript("OnMouseDown", Frame_OnMouseDown)
 
local closebutton = CreateFrame("Button", nil, frame, "UIPanelButtonTemplate")
closebutton:SetScript("OnClick", Button_OnClick)
closebutton:SetPoint("BOTTOMRIGHT", -27, 17)
closebutton:SetHeight(20)
closebutton:SetWidth(100)
closebutton:SetText(CLOSE)
 
local statusbg = CreateFrame("Button", nil, frame)
statusbg:SetPoint("BOTTOMLEFT", 15, 15)
statusbg:SetPoint("BOTTOMRIGHT", -132, 15)
statusbg:SetHeight(24)
statusbg:SetBackdrop(PaneBackdrop)
statusbg:SetBackdropColor(0.1,0.1,0.1)
statusbg:SetBackdropBorderColor(0.4,0.4,0.4)
statusbg:SetScript("OnEnter", StatusBar_OnEnter)
statusbg:SetScript("OnLeave", StatusBar_OnLeave)
 
local statustext = statusbg:CreateFontString(nil, "OVERLAY", "GameFontNormal")
statustext:SetPoint("TOPLEFT", 7, -2)
statustext:SetPoint("BOTTOMRIGHT", -7, 2)
statustext:SetHeight(20)
statustext:SetJustifyH("LEFT")
statustext:SetText("")
 
local titlebg = frame:CreateTexture(nil, "OVERLAY")
titlebg:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header")
titlebg:SetTexCoord(0.31, 0.67, 0, 0.63)
titlebg:SetPoint("TOP", 0, 12)
titlebg:SetWidth(100)
titlebg:SetHeight(40)
 
local title = CreateFrame("Frame", nil, frame)
title:EnableMouse(true)
title:SetScript("OnMouseDown", Title_OnMouseDown)
title:SetScript("OnMouseUp", MoverSizer_OnMouseUp)
title:SetAllPoints(titlebg)
 
local titletext = title:CreateFontString(nil, "OVERLAY", "GameFontNormal")
titletext:SetPoint("TOP", titlebg, "TOP", 0, -14)
 
local titlebg_l = frame:CreateTexture(nil, "OVERLAY")
titlebg_l:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header")
titlebg_l:SetTexCoord(0.21, 0.31, 0, 0.63)
titlebg_l:SetPoint("RIGHT", titlebg, "LEFT")
titlebg_l:SetWidth(30)
titlebg_l:SetHeight(40)
 
local titlebg_r = frame:CreateTexture(nil, "OVERLAY")
titlebg_r:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header")
titlebg_r:SetTexCoord(0.67, 0.77, 0, 0.63)
titlebg_r:SetPoint("LEFT", titlebg, "RIGHT")
titlebg_r:SetWidth(30)
titlebg_r:SetHeight(40)
 
local sizer_se = CreateFrame("Frame", nil, frame)
sizer_se:SetPoint("BOTTOMRIGHT")
sizer_se:SetWidth(25)
sizer_se:SetHeight(25)
sizer_se:EnableMouse()
sizer_se:SetScript("OnMouseDown",SizerSE_OnMouseDown)
sizer_se:SetScript("OnMouseUp", MoverSizer_OnMouseUp)
 
local line1 = sizer_se:CreateTexture(nil, "BACKGROUND")
line1:SetWidth(14)
line1:SetHeight(14)
line1:SetPoint("BOTTOMRIGHT", -8, 8)
line1:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border")
local x = 0.1 * 14/17
line1:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5)
 
local line2 = sizer_se:CreateTexture(nil, "BACKGROUND")
line2:SetWidth(8)
line2:SetHeight(8)
line2:SetPoint("BOTTOMRIGHT", -8, 8)
line2:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border")
local x = 0.1 * 8/17
line2:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5)
 
local sizer_s = CreateFrame("Frame", nil, frame)
sizer_s:SetPoint("BOTTOMRIGHT", -25, 0)
sizer_s:SetPoint("BOTTOMLEFT")
sizer_s:SetHeight(25)
sizer_s:EnableMouse(true)
sizer_s:SetScript("OnMouseDown", SizerS_OnMouseDown)
sizer_s:SetScript("OnMouseUp", MoverSizer_OnMouseUp)
 
local sizer_e = CreateFrame("Frame", nil, frame)
sizer_e:SetPoint("BOTTOMRIGHT", 0, 25)
sizer_e:SetPoint("TOPRIGHT")
sizer_e:SetWidth(25)
sizer_e:EnableMouse(true)
sizer_e:SetScript("OnMouseDown", SizerE_OnMouseDown)
sizer_e:SetScript("OnMouseUp", MoverSizer_OnMouseUp)
 
--Container Support
local content = CreateFrame("Frame", nil, frame)
content:SetPoint("TOPLEFT", 17, -27)
content:SetPoint("BOTTOMRIGHT", -17, 40)
 
local widget = {
localstatus = {},
titletext = titletext,
statustext = statustext,
content = content,
frame = frame,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
closebutton.obj, statusbg.obj = widget, widget
 
return AceGUI:RegisterAsContainer(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIContainer-InlineGroup.lua New file
0,0 → 1,102
--[[-----------------------------------------------------------------------------
InlineGroup Container
Simple container widget that creates a visible "box" with an optional title.
-------------------------------------------------------------------------------]]
local Type, Version = "InlineGroup", 20
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local pairs = pairs
 
-- WoW APIs
local CreateFrame, UIParent = CreateFrame, UIParent
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetWidth(300)
self:SetHeight(100)
end,
 
-- ["OnRelease"] = nil,
 
["SetTitle"] = function(self,title)
self.titletext:SetText(title)
end,
 
 
["LayoutFinished"] = function(self, width, height)
if self.noAutoHeight then return end
self:SetHeight((height or 0) + 40)
end,
 
["OnWidthSet"] = function(self, width)
local content = self.content
local contentwidth = width - 20
if contentwidth < 0 then
contentwidth = 0
end
content:SetWidth(contentwidth)
content.width = contentwidth
end,
 
["OnHeightSet"] = function(self, height)
local content = self.content
local contentheight = height - 20
if contentheight < 0 then
contentheight = 0
end
content:SetHeight(contentheight)
content.height = contentheight
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local PaneBackdrop = {
bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
tile = true, tileSize = 16, edgeSize = 16,
insets = { left = 3, right = 3, top = 5, bottom = 3 }
}
 
local function Constructor()
local frame = CreateFrame("Frame", nil, UIParent)
frame:SetFrameStrata("FULLSCREEN_DIALOG")
 
local titletext = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
titletext:SetPoint("TOPLEFT", 14, 0)
titletext:SetPoint("TOPRIGHT", -14, 0)
titletext:SetJustifyH("LEFT")
titletext:SetHeight(18)
 
local border = CreateFrame("Frame", nil, frame)
border:SetPoint("TOPLEFT", 0, -17)
border:SetPoint("BOTTOMRIGHT", -1, 3)
border:SetBackdrop(PaneBackdrop)
border:SetBackdropColor(0.1, 0.1, 0.1, 0.5)
border:SetBackdropBorderColor(0.4, 0.4, 0.4)
 
--Container Support
local content = CreateFrame("Frame", nil, border)
content:SetPoint("TOPLEFT", 10, -10)
content:SetPoint("BOTTOMRIGHT", -10, 10)
 
local widget = {
frame = frame,
content = content,
titletext = titletext,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
 
return AceGUI:RegisterAsContainer(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIWidget-DropDown.lua New file
0,0 → 1,707
--[[ $Id: AceGUIWidget-DropDown.lua 916 2010-03-15 12:24:36Z nevcairiel $ ]]--
local AceGUI = LibStub("AceGUI-3.0")
 
-- Lua APIs
local min, max, floor = math.min, math.max, math.floor
local select, pairs, ipairs = select, pairs, ipairs
local tsort = table.sort
 
-- WoW APIs
local PlaySound = PlaySound
local UIParent, CreateFrame = UIParent, CreateFrame
local _G = _G
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: CLOSE
 
local function fixlevels(parent,...)
local i = 1
local child = select(i, ...)
while child do
child:SetFrameLevel(parent:GetFrameLevel()+1)
fixlevels(child, child:GetChildren())
i = i + 1
child = select(i, ...)
end
end
 
local function fixstrata(strata, parent, ...)
local i = 1
local child = select(i, ...)
parent:SetFrameStrata(strata)
while child do
fixstrata(strata, child, child:GetChildren())
i = i + 1
child = select(i, ...)
end
end
 
do
local widgetType = "Dropdown-Pullout"
local widgetVersion = 3
 
--[[ Static data ]]--
 
local backdrop = {
bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
edgeSize = 32,
tileSize = 32,
tile = true,
insets = { left = 11, right = 12, top = 12, bottom = 11 },
}
local sliderBackdrop = {
bgFile = "Interface\\Buttons\\UI-SliderBar-Background",
edgeFile = "Interface\\Buttons\\UI-SliderBar-Border",
tile = true, tileSize = 8, edgeSize = 8,
insets = { left = 3, right = 3, top = 3, bottom = 3 }
}
 
local defaultWidth = 200
local defaultMaxHeight = 600
 
--[[ UI Event Handlers ]]--
 
-- HACK: This should be no part of the pullout, but there
-- is no other 'clean' way to response to any item-OnEnter
-- Used to close Submenus when an other item is entered
local function OnEnter(item)
local self = item.pullout
for k, v in ipairs(self.items) do
if v.CloseMenu and v ~= item then
v:CloseMenu()
end
end
end
 
-- See the note in Constructor() for each scroll related function
local function OnMouseWheel(this, value)
this.obj:MoveScroll(value)
end
 
local function OnScrollValueChanged(this, value)
this.obj:SetScroll(value)
end
 
local function OnSizeChanged(this)
this.obj:FixScroll()
end
 
--[[ Exported methods ]]--
 
-- exported
local function SetScroll(self, value)
local status = self.scrollStatus
local frame, child = self.scrollFrame, self.itemFrame
local height, viewheight = frame:GetHeight(), child:GetHeight()
 
local offset
if height > viewheight then
offset = 0
else
offset = floor((viewheight - height) / 1000 * value)
end
child:ClearAllPoints()
child:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, offset)
child:SetPoint("TOPRIGHT", frame, "TOPRIGHT", self.slider:IsShown() and -12 or 0, offset)
status.offset = offset
status.scrollvalue = value
end
 
-- exported
local function MoveScroll(self, value)
local status = self.scrollStatus
local frame, child = self.scrollFrame, self.itemFrame
local height, viewheight = frame:GetHeight(), child:GetHeight()
 
if height > viewheight then
self.slider:Hide()
else
self.slider:Show()
local diff = height - viewheight
local delta = 1
if value < 0 then
delta = -1
end
self.slider:SetValue(min(max(status.scrollvalue + delta*(1000/(diff/45)),0), 1000))
end
end
 
-- exported
local function FixScroll(self)
local status = self.scrollStatus
local frame, child = self.scrollFrame, self.itemFrame
local height, viewheight = frame:GetHeight(), child:GetHeight()
local offset = status.offset or 0
 
if viewheight < height then
self.slider:Hide()
child:SetPoint("TOPRIGHT", frame, "TOPRIGHT", 0, offset)
self.slider:SetValue(0)
else
self.slider:Show()
local value = (offset / (viewheight - height) * 1000)
if value > 1000 then value = 1000 end
self.slider:SetValue(value)
self:SetScroll(value)
if value < 1000 then
child:ClearAllPoints()
child:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, offset)
child:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -12, offset)
status.offset = offset
end
end
end
 
-- exported, AceGUI callback
local function OnAcquire(self)
self.frame:SetParent(UIParent)
--self.itemFrame:SetToplevel(true)
end
 
-- exported, AceGUI callback
local function OnRelease(self)
self:Clear()
self.frame:ClearAllPoints()
self.frame:Hide()
end
 
-- exported
local function AddItem(self, item)
self.items[#self.items + 1] = item
 
local h = #self.items * 16
self.itemFrame:SetHeight(h)
self.frame:SetHeight(min(h + 34, self.maxHeight)) -- +34: 20 for scrollFrame placement (10 offset) and +14 for item placement
 
item.frame:SetPoint("LEFT", self.itemFrame, "LEFT")
item.frame:SetPoint("RIGHT", self.itemFrame, "RIGHT")
 
item:SetPullout(self)
item:SetOnEnter(OnEnter)
end
 
-- exported
local function Open(self, point, relFrame, relPoint, x, y)
local items = self.items
local frame = self.frame
local itemFrame = self.itemFrame
 
frame:SetPoint(point, relFrame, relPoint, x, y)
 
 
local height = 8
for i, item in pairs(items) do
if i == 1 then
item:SetPoint("TOP", itemFrame, "TOP", 0, -2)
else
item:SetPoint("TOP", items[i-1].frame, "BOTTOM", 0, 1)
end
 
item:Show()
 
height = height + 16
end
itemFrame:SetHeight(height)
fixstrata("TOOLTIP", frame, frame:GetChildren())
frame:Show()
self:Fire("OnOpen")
end
 
-- exported
local function Close(self)
self.frame:Hide()
self:Fire("OnClose")
end
 
-- exported
local function Clear(self)
local items = self.items
for i, item in pairs(items) do
AceGUI:Release(item)
items[i] = nil
end
end
 
-- exported
local function IterateItems(self)
return ipairs(self.items)
end
 
-- exported
local function SetHideOnLeave(self, val)
self.hideOnLeave = val
end
 
-- exported
local function SetMaxHeight(self, height)
self.maxHeight = height or defaultMaxHeight
if self.frame:GetHeight() > height then
self.frame:SetHeight(height)
elseif (self.itemFrame:GetHeight() + 34) < height then
self.frame:SetHeight(self.itemFrame:GetHeight() + 34) -- see :AddItem
end
end
 
-- exported
local function GetRightBorderWidth(self)
return 6 + (self.slider:IsShown() and 12 or 0)
end
 
-- exported
local function GetLeftBorderWidth(self)
return 6
end
 
--[[ Constructor ]]--
 
local function Constructor()
local count = AceGUI:GetNextWidgetNum(widgetType)
local frame = CreateFrame("Frame", "AceGUI30Pullout"..count, UIParent)
local self = {}
self.count = count
self.type = widgetType
self.frame = frame
frame.obj = self
 
self.OnAcquire = OnAcquire
self.OnRelease = OnRelease
 
self.AddItem = AddItem
self.Open = Open
self.Close = Close
self.Clear = Clear
self.IterateItems = IterateItems
self.SetHideOnLeave = SetHideOnLeave
 
self.SetScroll = SetScroll
self.MoveScroll = MoveScroll
self.FixScroll = FixScroll
 
self.SetMaxHeight = SetMaxHeight
self.GetRightBorderWidth = GetRightBorderWidth
self.GetLeftBorderWidth = GetLeftBorderWidth
 
self.items = {}
 
self.scrollStatus = {
scrollvalue = 0,
}
 
self.maxHeight = defaultMaxHeight
 
frame:SetBackdrop(backdrop)
frame:SetBackdropColor(0, 0, 0)
frame:SetFrameStrata("FULLSCREEN_DIALOG")
frame:SetClampedToScreen(true)
frame:SetWidth(defaultWidth)
frame:SetHeight(self.maxHeight)
--frame:SetToplevel(true)
 
-- NOTE: The whole scroll frame code is copied from the AceGUI-3.0 widget ScrollFrame
local scrollFrame = CreateFrame("ScrollFrame", nil, frame)
local itemFrame = CreateFrame("Frame", nil, scrollFrame)
 
self.scrollFrame = scrollFrame
self.itemFrame = itemFrame
 
scrollFrame.obj = self
itemFrame.obj = self
 
local slider = CreateFrame("Slider", "AceGUI30PulloutScrollbar"..count, scrollFrame)
slider:SetOrientation("VERTICAL")
slider:SetHitRectInsets(0, 0, -10, 0)
slider:SetBackdrop(sliderBackdrop)
slider:SetWidth(8)
slider:SetThumbTexture("Interface\\Buttons\\UI-SliderBar-Button-Vertical")
slider:SetFrameStrata("FULLSCREEN_DIALOG")
self.slider = slider
slider.obj = self
 
scrollFrame:SetScrollChild(itemFrame)
scrollFrame:SetPoint("TOPLEFT", frame, "TOPLEFT", 6, -12)
scrollFrame:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -6, 12)
scrollFrame:EnableMouseWheel(true)
scrollFrame:SetScript("OnMouseWheel", OnMouseWheel)
scrollFrame:SetScript("OnSizeChanged", OnSizeChanged)
scrollFrame:SetToplevel(true)
scrollFrame:SetFrameStrata("FULLSCREEN_DIALOG")
 
itemFrame:SetPoint("TOPLEFT", scrollFrame, "TOPLEFT", 0, 0)
itemFrame:SetPoint("TOPRIGHT", scrollFrame, "TOPRIGHT", -12, 0)
itemFrame:SetHeight(400)
itemFrame:SetToplevel(true)
itemFrame:SetFrameStrata("FULLSCREEN_DIALOG")
 
slider:SetPoint("TOPLEFT", scrollFrame, "TOPRIGHT", -16, 0)
slider:SetPoint("BOTTOMLEFT", scrollFrame, "BOTTOMRIGHT", -16, 0)
slider:SetScript("OnValueChanged", OnScrollValueChanged)
slider:SetMinMaxValues(0, 1000)
slider:SetValueStep(1)
slider:SetValue(0)
 
scrollFrame:Show()
itemFrame:Show()
slider:Hide()
 
self:FixScroll()
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion)
end
 
do
local widgetType = "Dropdown"
local widgetVersion = 22
 
--[[ Static data ]]--
 
--[[ UI event handler ]]--
 
local function Control_OnEnter(this)
this.obj:Fire("OnEnter")
end
 
local function Control_OnLeave(this)
this.obj:Fire("OnLeave")
end
 
local function Dropdown_OnHide(this)
local self = this.obj
if self.open then
self.pullout:Close()
end
end
 
local function Dropdown_TogglePullout(this)
local self = this.obj
PlaySound("igMainMenuOptionCheckBoxOn") -- missleading name, but the Blizzard code uses this sound
if self.open then
self.open = nil
self.pullout:Close()
AceGUI:ClearFocus()
else
self.open = true
self.pullout:SetWidth(self.frame:GetWidth())
self.pullout:Open("TOPLEFT", self.frame, "BOTTOMLEFT", 0, self.label:IsShown() and -2 or 0)
AceGUI:SetFocus(self)
end
end
 
local function OnPulloutOpen(this)
local self = this.userdata.obj
local value = self.value
 
if not self.multiselect then
for i, item in this:IterateItems() do
item:SetValue(item.userdata.value == value)
end
end
 
self.open = true
end
 
local function OnPulloutClose(this)
local self = this.userdata.obj
self.open = nil
self:Fire("OnClosed")
end
 
local function ShowMultiText(self)
local text
for i, widget in self.pullout:IterateItems() do
if widget.type == "Dropdown-Item-Toggle" then
if widget:GetValue() then
if text then
text = text..", "..widget:GetText()
else
text = widget:GetText()
end
end
end
end
self:SetText(text)
end
 
local function OnItemValueChanged(this, event, checked)
local self = this.userdata.obj
 
if self.multiselect then
self:Fire("OnValueChanged", this.userdata.value, checked)
ShowMultiText(self)
else
if checked then
self:SetValue(this.userdata.value)
self:Fire("OnValueChanged", this.userdata.value)
else
this:SetValue(true)
end
if self.open then
self.pullout:Close()
end
end
end
 
--[[ Exported methods ]]--
 
-- exported, AceGUI callback
local function OnAcquire(self)
local pullout = AceGUI:Create("Dropdown-Pullout")
self.pullout = pullout
pullout.userdata.obj = self
pullout:SetCallback("OnClose", OnPulloutClose)
pullout:SetCallback("OnOpen", OnPulloutOpen)
self.pullout.frame:SetFrameLevel(self.frame:GetFrameLevel() + 1)
fixlevels(self.pullout.frame, self.pullout.frame:GetChildren())
 
self:SetHeight(44)
self:SetWidth(200)
end
 
-- exported, AceGUI callback
local function OnRelease(self)
if self.open then
self.pullout:Close()
end
AceGUI:Release(self.pullout)
self.pullout = nil
 
self:SetText("")
self:SetLabel("")
self:SetDisabled(false)
self:SetMultiselect(false)
 
self.value = nil
self.list = nil
self.open = nil
self.hasClose = nil
 
self.frame:ClearAllPoints()
self.frame:Hide()
end
 
-- exported
local function SetDisabled(self, disabled)
self.disabled = disabled
if disabled then
self.text:SetTextColor(0.5,0.5,0.5)
self.button:Disable()
self.label:SetTextColor(0.5,0.5,0.5)
else
self.button:Enable()
self.label:SetTextColor(1,.82,0)
self.text:SetTextColor(1,1,1)
end
end
 
-- exported
local function ClearFocus(self)
if self.open then
self.pullout:Close()
end
end
 
-- exported
local function SetText(self, text)
self.text:SetText(text or "")
end
 
-- exported
local function SetLabel(self, text)
if text and text ~= "" then
self.label:SetText(text)
self.label:Show()
self.dropdown:SetPoint("TOPLEFT",self.frame,"TOPLEFT",-15,-18)
self.frame:SetHeight(44)
else
self.label:SetText("")
self.label:Hide()
self.dropdown:SetPoint("TOPLEFT",self.frame,"TOPLEFT",-15,0)
self.frame:SetHeight(26)
end
end
 
-- exported
local function SetValue(self, value)
if self.list then
self:SetText(self.list[value] or "")
end
self.value = value
end
 
-- exported
local function GetValue(self)
return self.value
end
 
-- exported
local function SetItemValue(self, item, value)
if not self.multiselect then return end
for i, widget in self.pullout:IterateItems() do
if widget.userdata.value == item then
if widget.SetValue then
widget:SetValue(value)
end
end
end
ShowMultiText(self)
end
 
-- exported
local function SetItemDisabled(self, item, disabled)
for i, widget in self.pullout:IterateItems() do
if widget.userdata.value == item then
widget:SetDisabled(disabled)
end
end
end
 
local function AddListItem(self, value, text)
local item = AceGUI:Create("Dropdown-Item-Toggle")
item:SetText(text)
item.userdata.obj = self
item.userdata.value = value
item:SetCallback("OnValueChanged", OnItemValueChanged)
self.pullout:AddItem(item)
end
 
local function AddCloseButton(self)
if not self.hasClose then
local close = AceGUI:Create("Dropdown-Item-Execute")
close:SetText(CLOSE)
self.pullout:AddItem(close)
self.hasClose = true
end
end
 
-- exported
local sortlist = {}
local function SetList(self, list)
self.list = list
self.pullout:Clear()
self.hasClose = nil
if not list then return end
 
for v in pairs(list) do
sortlist[#sortlist + 1] = v
end
tsort(sortlist)
 
for i, value in pairs(sortlist) do
AddListItem(self, value, list[value])
sortlist[i] = nil
end
if self.multiselect then
ShowMultiText(self)
AddCloseButton(self)
end
end
 
-- exported
local function AddItem(self, value, text)
if self.list then
self.list[value] = text
AddListItem(self, value, text)
end
end
 
-- exported
local function SetMultiselect(self, multi)
self.multiselect = multi
if multi then
ShowMultiText(self)
AddCloseButton(self)
end
end
 
-- exported
local function GetMultiselect(self)
return self.multiselect
end
 
--[[ Constructor ]]--
 
local function Constructor()
local count = AceGUI:GetNextWidgetNum(widgetType)
local frame = CreateFrame("Frame", nil, UIParent)
local dropdown = CreateFrame("Frame", "AceGUI30DropDown"..count, frame, "UIDropDownMenuTemplate")
 
local self = {}
self.type = widgetType
self.frame = frame
self.dropdown = dropdown
self.count = count
frame.obj = self
dropdown.obj = self
 
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
 
self.ClearFocus = ClearFocus
 
self.SetText = SetText
self.SetValue = SetValue
self.GetValue = GetValue
self.SetList = SetList
self.SetLabel = SetLabel
self.SetDisabled = SetDisabled
self.AddItem = AddItem
self.SetMultiselect = SetMultiselect
self.GetMultiselect = GetMultiselect
self.SetItemValue = SetItemValue
self.SetItemDisabled = SetItemDisabled
 
self.alignoffset = 31
 
frame:SetHeight(44)
frame:SetWidth(200)
frame:SetScript("OnHide",Dropdown_OnHide)
 
dropdown:ClearAllPoints()
dropdown:SetPoint("TOPLEFT",frame,"TOPLEFT",-15,0)
dropdown:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",17,0)
dropdown:SetScript("OnHide", nil)
 
local left = _G[dropdown:GetName() .. "Left"]
local middle = _G[dropdown:GetName() .. "Middle"]
local right = _G[dropdown:GetName() .. "Right"]
 
middle:ClearAllPoints()
right:ClearAllPoints()
 
middle:SetPoint("LEFT", left, "RIGHT", 0, 0)
middle:SetPoint("RIGHT", right, "LEFT", 0, 0)
right:SetPoint("TOPRIGHT", dropdown, "TOPRIGHT", 0, 17)
 
local button = _G[dropdown:GetName() .. "Button"]
self.button = button
button.obj = self
button:SetScript("OnEnter",Control_OnEnter)
button:SetScript("OnLeave",Control_OnLeave)
button:SetScript("OnClick",Dropdown_TogglePullout)
 
local text = _G[dropdown:GetName() .. "Text"]
self.text = text
text.obj = self
text:ClearAllPoints()
text:SetPoint("RIGHT", right, "RIGHT" ,-43, 2)
text:SetPoint("LEFT", left, "LEFT", 25, 2)
 
local label = frame:CreateFontString(nil,"OVERLAY","GameFontNormalSmall")
label:SetPoint("TOPLEFT",frame,"TOPLEFT",0,0)
label:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,0)
label:SetJustifyH("LEFT")
label:SetHeight(18)
label:Hide()
self.label = label
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion)
end
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIWidget-EditBox.lua New file
0,0 → 1,232
--[[-----------------------------------------------------------------------------
EditBox Widget
-------------------------------------------------------------------------------]]
local Type, Version = "EditBox", 23
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local tostring, pairs = tostring, pairs
 
-- WoW APIs
local PlaySound = PlaySound
local GetCursorInfo, ClearCursor, GetSpellInfo = GetCursorInfo, ClearCursor, GetSpellInfo
local CreateFrame, UIParent = CreateFrame, UIParent
local _G = _G
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: AceGUIEditBoxInsertLink, ChatFontNormal, OKAY
 
--[[-----------------------------------------------------------------------------
Support functions
-------------------------------------------------------------------------------]]
if not AceGUIEditBoxInsertLink then
-- upgradeable hook
hooksecurefunc("ChatEdit_InsertLink", function(...) return _G.AceGUIEditBoxInsertLink(...) end)
end
 
function _G.AceGUIEditBoxInsertLink(text)
for i = 1, AceGUI:GetWidgetCount(Type) do
local editbox = _G["AceGUI-3.0EditBox"..i]
if editbox and editbox:IsVisible() and editbox:HasFocus() then
editbox:Insert(text)
return true
end
end
end
 
local function ShowButton(self)
if not self.disablebutton then
self.button:Show()
self.editbox:SetTextInsets(0, 20, 3, 3)
end
end
 
local function HideButton(self)
self.button:Hide()
self.editbox:SetTextInsets(0, 0, 3, 3)
end
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function Control_OnEnter(frame)
frame.obj:Fire("OnEnter")
end
 
local function Control_OnLeave(frame)
frame.obj:Fire("OnLeave")
end
 
local function EditBox_OnEscapePressed(frame)
AceGUI:ClearFocus()
end
 
local function EditBox_OnEnterPressed(frame)
local self = frame.obj
local value = frame:GetText()
local cancel = self:Fire("OnEnterPressed", value)
if not cancel then
PlaySound("igMainMenuOptionCheckBoxOn")
HideButton(self)
end
end
 
local function EditBox_OnReceiveDrag(frame)
local self = frame.obj
local type, id, info = GetCursorInfo()
if type == "item" then
self:SetText(info)
self:Fire("OnEnterPressed", info)
ClearCursor()
elseif type == "spell" then
local name = GetSpellInfo(id, info)
self:SetText(name)
self:Fire("OnEnterPressed", name)
ClearCursor()
end
HideButton(self)
AceGUI:ClearFocus()
end
 
local function EditBox_OnTextChanged(frame)
local self = frame.obj
local value = frame:GetText()
if tostring(value) ~= tostring(self.lasttext) then
self:Fire("OnTextChanged", value)
self.lasttext = value
ShowButton(self)
end
end
 
local function Button_OnClick(frame)
local editbox = frame.obj.editbox
editbox:ClearFocus()
EditBox_OnEnterPressed(editbox)
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
-- height is controlled by SetLabel
self:SetWidth(200)
self:SetDisabled(false)
self:SetLabel()
self:SetText()
self:DisableButton(false)
self:SetMaxLetters(0)
end,
 
-- ["OnRelease"] = nil,
 
["SetDisabled"] = function(self, disabled)
self.disabled = disabled
if disabled then
self.editbox:EnableMouse(false)
self.editbox:ClearFocus()
self.editbox:SetTextColor(0.5,0.5,0.5)
self.label:SetTextColor(0.5,0.5,0.5)
else
self.editbox:EnableMouse(true)
self.editbox:SetTextColor(1,1,1)
self.label:SetTextColor(1,.82,0)
end
end,
 
["SetText"] = function(self, text)
self.lasttext = text or ""
self.editbox:SetText(text or "")
self.editbox:SetCursorPosition(0)
HideButton(self)
end,
 
["GetText"] = function(self, text)
return self.editbox:GetText()
end,
 
["SetLabel"] = function(self, text)
if text and text ~= "" then
self.label:SetText(text)
self.label:Show()
self.editbox:SetPoint("TOPLEFT",self.frame,"TOPLEFT",7,-18)
self:SetHeight(44)
self.alignoffset = 30
else
self.label:SetText("")
self.label:Hide()
self.editbox:SetPoint("TOPLEFT",self.frame,"TOPLEFT",7,0)
self:SetHeight(26)
self.alignoffset = 12
end
end,
 
["DisableButton"] = function(self, disabled)
self.disablebutton = disabled
if disabled then
HideButton(self)
end
end,
 
["SetMaxLetters"] = function (self, num)
self.editbox:SetMaxLetters(num or 0)
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local function Constructor()
local num = AceGUI:GetNextWidgetNum(Type)
local frame = CreateFrame("Frame", nil, UIParent)
frame:Hide()
 
local editbox = CreateFrame("EditBox", "AceGUI-3.0EditBox"..num, frame, "InputBoxTemplate")
editbox:SetAutoFocus(false)
editbox:SetFontObject(ChatFontNormal)
editbox:SetScript("OnEnter", Control_OnEnter)
editbox:SetScript("OnLeave", Control_OnLeave)
editbox:SetScript("OnEscapePressed", EditBox_OnEscapePressed)
editbox:SetScript("OnEnterPressed", EditBox_OnEnterPressed)
editbox:SetScript("OnTextChanged", EditBox_OnTextChanged)
editbox:SetScript("OnReceiveDrag", EditBox_OnReceiveDrag)
editbox:SetScript("OnMouseDown", EditBox_OnReceiveDrag)
editbox:SetTextInsets(0, 0, 3, 3)
editbox:SetMaxLetters(256)
editbox:SetPoint("BOTTOMLEFT", 6, 0)
editbox:SetPoint("BOTTOMRIGHT")
editbox:SetHeight(19)
 
local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
label:SetPoint("TOPLEFT", 0, -2)
label:SetPoint("TOPRIGHT", 0, -2)
label:SetJustifyH("LEFT")
label:SetHeight(18)
 
local button = CreateFrame("Button", nil, editbox, "UIPanelButtonTemplate")
button:SetWidth(40)
button:SetHeight(20)
button:SetPoint("RIGHT", -2, 0)
button:SetText(OKAY)
button:SetScript("OnClick", Button_OnClick)
button:Hide()
 
local widget = {
alignoffset = 30,
editbox = editbox,
label = label,
button = button,
frame = frame,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
editbox.obj, button.obj = widget, widget
 
return AceGUI:RegisterAsWidget(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIWidget-Heading.lua New file
0,0 → 1,78
--[[-----------------------------------------------------------------------------
Heading Widget
-------------------------------------------------------------------------------]]
local Type, Version = "Heading", 20
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local pairs = pairs
 
-- WoW APIs
local CreateFrame, UIParent = CreateFrame, UIParent
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetText()
self:SetFullWidth()
self:SetHeight(18)
end,
 
-- ["OnRelease"] = nil,
 
["SetText"] = function(self, text)
self.label:SetText(text or "")
if text and text ~= "" then
self.left:SetPoint("RIGHT", self.label, "LEFT", -5, 0)
self.right:Show()
else
self.left:SetPoint("RIGHT", -3, 0)
self.right:Hide()
end
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local function Constructor()
local frame = CreateFrame("Frame", nil, UIParent)
frame:Hide()
 
local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontNormal")
label:SetPoint("TOP")
label:SetPoint("BOTTOM")
label:SetJustifyH("CENTER")
 
local left = frame:CreateTexture(nil, "BACKGROUND")
left:SetHeight(8)
left:SetPoint("LEFT", 3, 0)
left:SetPoint("RIGHT", label, "LEFT", -5, 0)
left:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border")
left:SetTexCoord(0.81, 0.94, 0.5, 1)
 
local right = frame:CreateTexture(nil, "BACKGROUND")
right:SetHeight(8)
right:SetPoint("RIGHT", -3, 0)
right:SetPoint("LEFT", label, "RIGHT", 5, 0)
right:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border")
right:SetTexCoord(0.81, 0.94, 0.5, 1)
 
local widget = {
label = label,
left = left,
right = right,
frame = frame,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
 
return AceGUI:RegisterAsWidget(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIContainer-SimpleGroup.lua New file
0,0 → 1,69
--[[-----------------------------------------------------------------------------
SimpleGroup Container
Simple container widget that just groups widgets.
-------------------------------------------------------------------------------]]
local Type, Version = "SimpleGroup", 20
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local pairs = pairs
 
-- WoW APIs
local CreateFrame, UIParent = CreateFrame, UIParent
 
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetWidth(300)
self:SetHeight(100)
end,
 
-- ["OnRelease"] = nil,
 
["LayoutFinished"] = function(self, width, height)
if self.noAutoHeight then return end
self:SetHeight(height or 0)
end,
 
["OnWidthSet"] = function(self, width)
local content = self.content
content:SetWidth(width)
content.width = width
end,
 
["OnHeightSet"] = function(self, height)
local content = self.content
content:SetHeight(height)
content.height = height
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local function Constructor()
local frame = CreateFrame("Frame", nil, UIParent)
frame:SetFrameStrata("FULLSCREEN_DIALOG")
 
--Container Support
local content = CreateFrame("Frame", nil, frame)
content:SetPoint("TOPLEFT")
content:SetPoint("BOTTOMRIGHT")
 
local widget = {
frame = frame,
content = content,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
 
return AceGUI:RegisterAsContainer(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIContainer-Window.lua New file
0,0 → 1,331
local AceGUI = LibStub("AceGUI-3.0")
 
-- Lua APIs
local pairs, assert, type = pairs, assert, type
 
-- WoW APIs
local PlaySound = PlaySound
local CreateFrame, UIParent = CreateFrame, UIParent
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: GameFontNormal
 
----------------
-- Main Frame --
----------------
--[[
Events :
OnClose
 
]]
do
local Type = "Window"
local Version = 4
 
local function frameOnClose(this)
this.obj:Fire("OnClose")
end
 
local function closeOnClick(this)
PlaySound("gsTitleOptionExit")
this.obj:Hide()
end
 
local function frameOnMouseDown(this)
AceGUI:ClearFocus()
end
 
local function titleOnMouseDown(this)
this:GetParent():StartMoving()
AceGUI:ClearFocus()
end
 
local function frameOnMouseUp(this)
local frame = this:GetParent()
frame:StopMovingOrSizing()
local self = frame.obj
local status = self.status or self.localstatus
status.width = frame:GetWidth()
status.height = frame:GetHeight()
status.top = frame:GetTop()
status.left = frame:GetLeft()
end
 
local function sizerseOnMouseDown(this)
this:GetParent():StartSizing("BOTTOMRIGHT")
AceGUI:ClearFocus()
end
 
local function sizersOnMouseDown(this)
this:GetParent():StartSizing("BOTTOM")
AceGUI:ClearFocus()
end
 
local function sizereOnMouseDown(this)
this:GetParent():StartSizing("RIGHT")
AceGUI:ClearFocus()
end
 
local function sizerOnMouseUp(this)
this:GetParent():StopMovingOrSizing()
end
 
local function SetTitle(self,title)
self.titletext:SetText(title)
end
 
local function SetStatusText(self,text)
-- self.statustext:SetText(text)
end
 
local function Hide(self)
self.frame:Hide()
end
 
local function Show(self)
self.frame:Show()
end
 
local function OnAcquire(self)
self.frame:SetParent(UIParent)
self.frame:SetFrameStrata("FULLSCREEN_DIALOG")
self:ApplyStatus()
self:EnableResize(true)
self:Show()
end
 
local function OnRelease(self)
self.status = nil
for k in pairs(self.localstatus) do
self.localstatus[k] = nil
end
end
 
-- called to set an external table to store status in
local function SetStatusTable(self, status)
assert(type(status) == "table")
self.status = status
self:ApplyStatus()
end
 
local function ApplyStatus(self)
local status = self.status or self.localstatus
local frame = self.frame
self:SetWidth(status.width or 700)
self:SetHeight(status.height or 500)
if status.top and status.left then
frame:SetPoint("TOP",UIParent,"BOTTOM",0,status.top)
frame:SetPoint("LEFT",UIParent,"LEFT",status.left,0)
else
frame:SetPoint("CENTER",UIParent,"CENTER")
end
end
 
local function OnWidthSet(self, width)
local content = self.content
local contentwidth = width - 34
if contentwidth < 0 then
contentwidth = 0
end
content:SetWidth(contentwidth)
content.width = contentwidth
end
 
 
local function OnHeightSet(self, height)
local content = self.content
local contentheight = height - 57
if contentheight < 0 then
contentheight = 0
end
content:SetHeight(contentheight)
content.height = contentheight
end
 
local function EnableResize(self, state)
local func = state and "Show" or "Hide"
self.sizer_se[func](self.sizer_se)
self.sizer_s[func](self.sizer_s)
self.sizer_e[func](self.sizer_e)
end
 
local function Constructor()
local frame = CreateFrame("Frame",nil,UIParent)
local self = {}
self.type = "Window"
 
self.Hide = Hide
self.Show = Show
self.SetTitle = SetTitle
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
self.SetStatusText = SetStatusText
self.SetStatusTable = SetStatusTable
self.ApplyStatus = ApplyStatus
self.OnWidthSet = OnWidthSet
self.OnHeightSet = OnHeightSet
self.EnableResize = EnableResize
 
self.localstatus = {}
 
self.frame = frame
frame.obj = self
frame:SetWidth(700)
frame:SetHeight(500)
frame:SetPoint("CENTER",UIParent,"CENTER",0,0)
frame:EnableMouse()
frame:SetMovable(true)
frame:SetResizable(true)
frame:SetFrameStrata("FULLSCREEN_DIALOG")
frame:SetScript("OnMouseDown", frameOnMouseDown)
 
frame:SetScript("OnHide",frameOnClose)
frame:SetMinResize(240,240)
frame:SetToplevel(true)
 
local titlebg = frame:CreateTexture(nil, "BACKGROUND")
titlebg:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Title-Background]])
titlebg:SetPoint("TOPLEFT", 9, -6)
titlebg:SetPoint("BOTTOMRIGHT", frame, "TOPRIGHT", -28, -24)
 
local dialogbg = frame:CreateTexture(nil, "BACKGROUND")
dialogbg:SetTexture([[Interface\Tooltips\UI-Tooltip-Background]])
dialogbg:SetPoint("TOPLEFT", 8, -24)
dialogbg:SetPoint("BOTTOMRIGHT", -6, 8)
dialogbg:SetVertexColor(0, 0, 0, .75)
 
local topleft = frame:CreateTexture(nil, "BORDER")
topleft:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]])
topleft:SetWidth(64)
topleft:SetHeight(64)
topleft:SetPoint("TOPLEFT")
topleft:SetTexCoord(0.501953125, 0.625, 0, 1)
 
local topright = frame:CreateTexture(nil, "BORDER")
topright:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]])
topright:SetWidth(64)
topright:SetHeight(64)
topright:SetPoint("TOPRIGHT")
topright:SetTexCoord(0.625, 0.75, 0, 1)
 
local top = frame:CreateTexture(nil, "BORDER")
top:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]])
top:SetHeight(64)
top:SetPoint("TOPLEFT", topleft, "TOPRIGHT")
top:SetPoint("TOPRIGHT", topright, "TOPLEFT")
top:SetTexCoord(0.25, 0.369140625, 0, 1)
 
local bottomleft = frame:CreateTexture(nil, "BORDER")
bottomleft:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]])
bottomleft:SetWidth(64)
bottomleft:SetHeight(64)
bottomleft:SetPoint("BOTTOMLEFT")
bottomleft:SetTexCoord(0.751953125, 0.875, 0, 1)
 
local bottomright = frame:CreateTexture(nil, "BORDER")
bottomright:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]])
bottomright:SetWidth(64)
bottomright:SetHeight(64)
bottomright:SetPoint("BOTTOMRIGHT")
bottomright:SetTexCoord(0.875, 1, 0, 1)
 
local bottom = frame:CreateTexture(nil, "BORDER")
bottom:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]])
bottom:SetHeight(64)
bottom:SetPoint("BOTTOMLEFT", bottomleft, "BOTTOMRIGHT")
bottom:SetPoint("BOTTOMRIGHT", bottomright, "BOTTOMLEFT")
bottom:SetTexCoord(0.376953125, 0.498046875, 0, 1)
 
local left = frame:CreateTexture(nil, "BORDER")
left:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]])
left:SetWidth(64)
left:SetPoint("TOPLEFT", topleft, "BOTTOMLEFT")
left:SetPoint("BOTTOMLEFT", bottomleft, "TOPLEFT")
left:SetTexCoord(0.001953125, 0.125, 0, 1)
 
local right = frame:CreateTexture(nil, "BORDER")
right:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]])
right:SetWidth(64)
right:SetPoint("TOPRIGHT", topright, "BOTTOMRIGHT")
right:SetPoint("BOTTOMRIGHT", bottomright, "TOPRIGHT")
right:SetTexCoord(0.1171875, 0.2421875, 0, 1)
 
local close = CreateFrame("Button", nil, frame, "UIPanelCloseButton")
close:SetPoint("TOPRIGHT", 2, 1)
close:SetScript("OnClick", closeOnClick)
self.closebutton = close
close.obj = self
 
local titletext = frame:CreateFontString(nil, "ARTWORK")
titletext:SetFontObject(GameFontNormal)
titletext:SetPoint("TOPLEFT", 12, -8)
titletext:SetPoint("TOPRIGHT", -32, -8)
self.titletext = titletext
 
local title = CreateFrame("Button", nil, frame)
title:SetPoint("TOPLEFT", titlebg)
title:SetPoint("BOTTOMRIGHT", titlebg)
title:EnableMouse()
title:SetScript("OnMouseDown",titleOnMouseDown)
title:SetScript("OnMouseUp", frameOnMouseUp)
self.title = title
 
local sizer_se = CreateFrame("Frame",nil,frame)
sizer_se:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,0)
sizer_se:SetWidth(25)
sizer_se:SetHeight(25)
sizer_se:EnableMouse()
sizer_se:SetScript("OnMouseDown",sizerseOnMouseDown)
sizer_se:SetScript("OnMouseUp", sizerOnMouseUp)
self.sizer_se = sizer_se
 
local line1 = sizer_se:CreateTexture(nil, "BACKGROUND")
self.line1 = line1
line1:SetWidth(14)
line1:SetHeight(14)
line1:SetPoint("BOTTOMRIGHT", -8, 8)
line1:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border")
local x = 0.1 * 14/17
line1:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5)
 
local line2 = sizer_se:CreateTexture(nil, "BACKGROUND")
self.line2 = line2
line2:SetWidth(8)
line2:SetHeight(8)
line2:SetPoint("BOTTOMRIGHT", -8, 8)
line2:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border")
local x = 0.1 * 8/17
line2:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5)
 
local sizer_s = CreateFrame("Frame",nil,frame)
sizer_s:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-25,0)
sizer_s:SetPoint("BOTTOMLEFT",frame,"BOTTOMLEFT",0,0)
sizer_s:SetHeight(25)
sizer_s:EnableMouse()
sizer_s:SetScript("OnMouseDown",sizersOnMouseDown)
sizer_s:SetScript("OnMouseUp", sizerOnMouseUp)
self.sizer_s = sizer_s
 
local sizer_e = CreateFrame("Frame",nil,frame)
sizer_e:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,25)
sizer_e:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,0)
sizer_e:SetWidth(25)
sizer_e:EnableMouse()
sizer_e:SetScript("OnMouseDown",sizereOnMouseDown)
sizer_e:SetScript("OnMouseUp", sizerOnMouseUp)
self.sizer_e = sizer_e
 
--Container Support
local content = CreateFrame("Frame",nil,frame)
self.content = content
content.obj = self
content:SetPoint("TOPLEFT",frame,"TOPLEFT",12,-32)
content:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-12,13)
 
AceGUI:RegisterAsContainer(self)
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIContainer-DropDownGroup.lua New file
0,0 → 1,157
--[[-----------------------------------------------------------------------------
DropdownGroup Container
Container controlled by a dropdown on the top.
-------------------------------------------------------------------------------]]
local Type, Version = "DropdownGroup", 20
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local assert, pairs, type = assert, pairs, type
 
-- WoW APIs
local CreateFrame = CreateFrame
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function SelectedGroup(self, event, value)
local group = self.parentgroup
local status = group.status or group.localstatus
status.selected = value
self.parentgroup:Fire("OnGroupSelected", value)
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self.dropdown:SetText("")
self:SetDropdownWidth(200)
self:SetTitle("")
end,
 
["OnRelease"] = function(self)
self.dropdown.list = nil
self.status = nil
for k in pairs(self.localstatus) do
self.localstatus[k] = nil
end
end,
 
["SetTitle"] = function(self, title)
self.titletext:SetText(title)
self.dropdown.frame:ClearAllPoints()
if title and title ~= "" then
self.dropdown.frame:SetPoint("TOPRIGHT", -2, 0)
else
self.dropdown.frame:SetPoint("TOPLEFT", -1, 0)
end
end,
 
["SetGroupList"] = function(self,list)
self.dropdown:SetList(list)
end,
 
["SetStatusTable"] = function(self, status)
assert(type(status) == "table")
self.status = status
end,
 
["SetGroup"] = function(self,group)
self.dropdown:SetValue(group)
local status = self.status or self.localstatus
status.selected = group
self:Fire("OnGroupSelected", group)
end,
 
["OnWidthSet"] = function(self, width)
local content = self.content
local contentwidth = width - 26
if contentwidth < 0 then
contentwidth = 0
end
content:SetWidth(contentwidth)
content.width = contentwidth
end,
 
["OnHeightSet"] = function(self, height)
local content = self.content
local contentheight = height - 63
if contentheight < 0 then
contentheight = 0
end
content:SetHeight(contentheight)
content.height = contentheight
end,
 
["LayoutFinished"] = function(self, width, height)
self:SetHeight((height or 0) + 63)
end,
 
["SetDropdownWidth"] = function(self, width)
self.dropdown:SetWidth(width)
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local PaneBackdrop = {
bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
tile = true, tileSize = 16, edgeSize = 16,
insets = { left = 3, right = 3, top = 5, bottom = 3 }
}
 
local function Constructor()
local frame = CreateFrame("Frame")
frame:SetHeight(100)
frame:SetWidth(100)
frame:SetFrameStrata("FULLSCREEN_DIALOG")
 
local titletext = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
titletext:SetPoint("TOPLEFT", 4, -5)
titletext:SetPoint("TOPRIGHT", -4, -5)
titletext:SetJustifyH("LEFT")
titletext:SetHeight(18)
 
local dropdown = AceGUI:Create("Dropdown")
dropdown.frame:SetParent(frame)
dropdown.frame:SetFrameLevel(dropdown.frame:GetFrameLevel() + 2)
dropdown:SetCallback("OnValueChanged", SelectedGroup)
dropdown.frame:SetPoint("TOPLEFT", -1, 0)
dropdown.frame:Show()
dropdown:SetLabel("")
 
local border = CreateFrame("Frame", nil, frame)
border:SetPoint("TOPLEFT", 0, -26)
border:SetPoint("BOTTOMRIGHT", 0, 3)
border:SetBackdrop(PaneBackdrop)
border:SetBackdropColor(0.1,0.1,0.1,0.5)
border:SetBackdropBorderColor(0.4,0.4,0.4)
 
--Container Support
local content = CreateFrame("Frame", nil, border)
content:SetPoint("TOPLEFT", 10, -10)
content:SetPoint("BOTTOMRIGHT", -10, 10)
 
local widget = {
frame = frame,
localstatus = {},
titletext = titletext,
dropdown = dropdown,
border = border,
content = content,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
dropdown.parentgroup = widget
 
return AceGUI:RegisterAsContainer(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIContainer-ScrollFrame.lua New file
0,0 → 1,203
--[[-----------------------------------------------------------------------------
ScrollFrame Container
Plain container that scrolls its content and doesn't grow in height.
-------------------------------------------------------------------------------]]
local Type, Version = "ScrollFrame", 21
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local pairs, assert, type = pairs, assert, type
local min, max, floor, abs = math.min, math.max, math.floor, math.abs
 
-- WoW APIs
local CreateFrame, UIParent = CreateFrame, UIParent
 
--[[-----------------------------------------------------------------------------
Support functions
-------------------------------------------------------------------------------]]
local function FixScrollOnUpdate(frame)
frame:SetScript("OnUpdate", nil)
frame.obj:FixScroll()
end
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function ScrollFrame_OnMouseWheel(frame, value)
frame.obj:MoveScroll(value)
end
 
local function ScrollFrame_OnSizeChanged(frame)
frame:SetScript("OnUpdate", FixScrollOnUpdate)
end
 
local function ScrollBar_OnScrollValueChanged(frame, value)
frame.obj:SetScroll(value)
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetScroll(0)
end,
 
["OnRelease"] = function(self)
self.status = nil
for k in pairs(self.localstatus) do
self.localstatus[k] = nil
end
self.scrollframe:SetPoint("BOTTOMRIGHT")
self.scrollbar:Hide()
self.scrollBarShown = nil
self.content.height, self.content.width = nil, nil
end,
 
["SetScroll"] = function(self, value)
local status = self.status or self.localstatus
local viewheight = self.scrollframe:GetHeight()
local height = self.content:GetHeight()
local offset
 
if viewheight > height then
offset = 0
else
offset = floor((height - viewheight) / 1000.0 * value)
end
self.content:ClearAllPoints()
self.content:SetPoint("TOPLEFT", 0, offset)
self.content:SetPoint("TOPRIGHT", 0, offset)
status.offset = offset
status.scrollvalue = value
end,
 
["MoveScroll"] = function(self, value)
local status = self.status or self.localstatus
local height, viewheight = self.scrollframe:GetHeight(), self.content:GetHeight()
 
if self.scrollBarShown then
local diff = height - viewheight
local delta = 1
if value < 0 then
delta = -1
end
self.scrollbar:SetValue(min(max(status.scrollvalue + delta*(1000/(diff/45)),0), 1000))
end
end,
 
["FixScroll"] = function(self)
if self.updateLock then return end
self.updateLock = true
local status = self.status or self.localstatus
local height, viewheight = self.scrollframe:GetHeight(), self.content:GetHeight()
local offset = status.offset or 0
local curvalue = self.scrollbar:GetValue()
-- Give us a margin of error of 2 pixels to stop some conditions that i would blame on floating point inaccuracys
-- No-one is going to miss 2 pixels at the bottom of the frame, anyhow!
if viewheight < height + 2 then
if self.scrollBarShown then
self.scrollBarShown = nil
self.scrollbar:Hide()
self.scrollbar:SetValue(0)
self.scrollframe:SetPoint("BOTTOMRIGHT")
self:DoLayout()
end
else
if not self.scrollBarShown then
self.scrollBarShown = true
self.scrollbar:Show()
self.scrollframe:SetPoint("BOTTOMRIGHT", -20, 0)
self:DoLayout()
end
local value = (offset / (viewheight - height) * 1000)
if value > 1000 then value = 1000 end
self.scrollbar:SetValue(value)
self:SetScroll(value)
if value < 1000 then
self.content:ClearAllPoints()
self.content:SetPoint("TOPLEFT", 0, offset)
self.content:SetPoint("TOPRIGHT", 0, offset)
status.offset = offset
end
end
self.updateLock = nil
end,
 
["LayoutFinished"] = function(self, width, height)
self.content:SetHeight(height or 0 + 20)
self.scrollframe:SetScript("OnUpdate", FixScrollOnUpdate)
end,
 
["SetStatusTable"] = function(self, status)
assert(type(status) == "table")
self.status = status
if not status.scrollvalue then
status.scrollvalue = 0
end
end,
 
["OnWidthSet"] = function(self, width)
local content = self.content
content.width = width
end,
 
["OnHeightSet"] = function(self, height)
local content = self.content
content.height = height
end
}
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local function Constructor()
local frame = CreateFrame("Frame", nil, UIParent)
local num = AceGUI:GetNextWidgetNum(Type)
 
local scrollframe = CreateFrame("ScrollFrame", nil, frame)
scrollframe:SetPoint("TOPLEFT")
scrollframe:SetPoint("BOTTOMRIGHT")
scrollframe:EnableMouseWheel(true)
scrollframe:SetScript("OnMouseWheel", ScrollFrame_OnMouseWheel)
scrollframe:SetScript("OnSizeChanged", ScrollFrame_OnSizeChanged)
 
local scrollbar = CreateFrame("Slider", ("AceConfigDialogScrollFrame%dScrollBar"):format(num), scrollframe, "UIPanelScrollBarTemplate")
scrollbar:SetPoint("TOPLEFT", scrollframe, "TOPRIGHT", 4, -16)
scrollbar:SetPoint("BOTTOMLEFT", scrollframe, "BOTTOMRIGHT", 4, 16)
scrollbar:SetMinMaxValues(0, 1000)
scrollbar:SetValueStep(1)
scrollbar:SetValue(0)
scrollbar:SetWidth(16)
scrollbar:Hide()
-- set the script as the last step, so it doesn't fire yet
scrollbar:SetScript("OnValueChanged", ScrollBar_OnScrollValueChanged)
 
local scrollbg = scrollbar:CreateTexture(nil, "BACKGROUND")
scrollbg:SetAllPoints(scrollbar)
scrollbg:SetTexture(0, 0, 0, 0.4)
 
--Container Support
local content = CreateFrame("Frame", nil, scrollframe)
content:SetPoint("TOPLEFT")
content:SetPoint("TOPRIGHT")
content:SetHeight(400)
scrollframe:SetScrollChild(content)
 
local widget = {
localstatus = { scrollvalue = 0 },
scrollframe = scrollframe,
scrollbar = scrollbar,
content = content,
frame = frame,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
scrollframe.obj, scrollbar.obj = widget, widget
 
return AceGUI:RegisterAsContainer(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIWidget-DropDown-Items.lua New file
0,0 → 1,465
--[[ $Id: AceGUIWidget-DropDown-Items.lua 916 2010-03-15 12:24:36Z nevcairiel $ ]]--
 
local AceGUI = LibStub("AceGUI-3.0")
 
-- Lua APIs
local select, assert = select, assert
 
-- WoW APIs
local PlaySound = PlaySound
local CreateFrame = CreateFrame
 
local function fixlevels(parent,...)
local i = 1
local child = select(i, ...)
while child do
child:SetFrameLevel(parent:GetFrameLevel()+1)
fixlevels(child, child:GetChildren())
i = i + 1
child = select(i, ...)
end
end
 
local function fixstrata(strata, parent, ...)
local i = 1
local child = select(i, ...)
parent:SetFrameStrata(strata)
while child do
fixstrata(strata, child, child:GetChildren())
i = i + 1
child = select(i, ...)
end
end
 
-- ItemBase is the base "class" for all dropdown items.
-- Each item has to use ItemBase.Create(widgetType) to
-- create an initial 'self' value.
-- ItemBase will add common functions and ui event handlers.
-- Be sure to keep basic usage when you override functions.
 
local ItemBase = {
-- NOTE: The ItemBase version is added to each item's version number
-- to ensure proper updates on ItemBase changes.
-- Use at least 1000er steps.
version = 1000,
counter = 0,
}
 
function ItemBase.Frame_OnEnter(this)
local self = this.obj
 
if self.useHighlight then
self.highlight:Show()
end
self:Fire("OnEnter")
 
if self.specialOnEnter then
self.specialOnEnter(self)
end
end
 
function ItemBase.Frame_OnLeave(this)
local self = this.obj
 
self.highlight:Hide()
self:Fire("OnLeave")
 
if self.specialOnLeave then
self.specialOnLeave(self)
end
end
 
-- exported, AceGUI callback
function ItemBase.OnAcquire(self)
self.frame:SetToplevel(true)
self.frame:SetFrameStrata("FULLSCREEN_DIALOG")
end
 
-- exported, AceGUI callback
function ItemBase.OnRelease(self)
self:SetDisabled(false)
self.pullout = nil
self.frame:SetParent(nil)
self.frame:ClearAllPoints()
self.frame:Hide()
end
 
-- exported
-- NOTE: this is called by a Dropdown-Pullout.
-- Do not call this method directly
function ItemBase.SetPullout(self, pullout)
self.pullout = pullout
 
self.frame:SetParent(nil)
self.frame:SetParent(pullout.itemFrame)
self.parent = pullout.itemFrame
fixlevels(pullout.itemFrame, pullout.itemFrame:GetChildren())
end
 
-- exported
function ItemBase.SetText(self, text)
self.text:SetText(text or "")
end
 
-- exported
function ItemBase.GetText(self)
return self.text:GetText()
end
 
-- exported
function ItemBase.SetPoint(self, ...)
self.frame:SetPoint(...)
end
 
-- exported
function ItemBase.Show(self)
self.frame:Show()
end
 
-- exported
function ItemBase.Hide(self)
self.frame:Hide()
end
 
-- exported
function ItemBase.SetDisabled(self, disabled)
self.disabled = disabled
if disabled then
self.useHighlight = false
self.text:SetTextColor(.5, .5, .5)
else
self.useHighlight = true
self.text:SetTextColor(1, 1, 1)
end
end
 
-- exported
-- NOTE: this is called by a Dropdown-Pullout.
-- Do not call this method directly
function ItemBase.SetOnLeave(self, func)
self.specialOnLeave = func
end
 
-- exported
-- NOTE: this is called by a Dropdown-Pullout.
-- Do not call this method directly
function ItemBase.SetOnEnter(self, func)
self.specialOnEnter = func
end
 
function ItemBase.Create(type)
-- NOTE: Most of the following code is copied from AceGUI-3.0/Dropdown widget
local count = AceGUI:GetNextWidgetNum(type)
local frame = CreateFrame("Button", "AceGUI30DropDownItem"..count)
local self = {}
self.frame = frame
frame.obj = self
self.type = type
 
self.useHighlight = true
 
frame:SetHeight(17)
frame:SetFrameStrata("FULLSCREEN_DIALOG")
 
local text = frame:CreateFontString(nil,"OVERLAY","GameFontNormalSmall")
text:SetTextColor(1,1,1)
text:SetJustifyH("LEFT")
text:SetPoint("TOPLEFT",frame,"TOPLEFT",18,0)
text:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-8,0)
self.text = text
 
local highlight = frame:CreateTexture(nil, "OVERLAY")
highlight:SetTexture("Interface\\QuestFrame\\UI-QuestTitleHighlight")
highlight:SetBlendMode("ADD")
highlight:SetHeight(14)
highlight:ClearAllPoints()
highlight:SetPoint("RIGHT",frame,"RIGHT",-3,0)
highlight:SetPoint("LEFT",frame,"LEFT",5,0)
highlight:Hide()
self.highlight = highlight
 
local check = frame:CreateTexture("OVERLAY")
check:SetWidth(16)
check:SetHeight(16)
check:SetPoint("LEFT",frame,"LEFT",3,-1)
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check")
check:Hide()
self.check = check
 
local sub = frame:CreateTexture("OVERLAY")
sub:SetWidth(16)
sub:SetHeight(16)
sub:SetPoint("RIGHT",frame,"RIGHT",-3,-1)
sub:SetTexture("Interface\\ChatFrame\\ChatFrameExpandArrow")
sub:Hide()
self.sub = sub
 
frame:SetScript("OnEnter", ItemBase.Frame_OnEnter)
frame:SetScript("OnLeave", ItemBase.Frame_OnLeave)
 
self.OnAcquire = ItemBase.OnAcquire
self.OnRelease = ItemBase.OnRelease
 
self.SetPullout = ItemBase.SetPullout
self.GetText = ItemBase.GetText
self.SetText = ItemBase.SetText
self.SetDisabled = ItemBase.SetDisabled
 
self.SetPoint = ItemBase.SetPoint
self.Show = ItemBase.Show
self.Hide = ItemBase.Hide
 
self.SetOnLeave = ItemBase.SetOnLeave
self.SetOnEnter = ItemBase.SetOnEnter
 
return self
end
 
--[[
Template for items:
 
-- Item:
--
do
local widgetType = "Dropdown-Item-"
local widgetVersion = 1
 
local function Constructor()
local self = ItemBase.Create(widgetType)
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
end
--]]
 
-- Item: Header
-- A single text entry.
-- Special: Different text color and no highlight
do
local widgetType = "Dropdown-Item-Header"
local widgetVersion = 1
 
local function OnEnter(this)
local self = this.obj
self:Fire("OnEnter")
 
if self.specialOnEnter then
self.specialOnEnter(self)
end
end
 
local function OnLeave(this)
local self = this.obj
self:Fire("OnLeave")
 
if self.specialOnLeave then
self.specialOnLeave(self)
end
end
 
-- exported, override
local function SetDisabled(self, disabled)
ItemBase.SetDisabled(self, disabled)
if not disabled then
self.text:SetTextColor(1, 1, 0)
end
end
 
local function Constructor()
local self = ItemBase.Create(widgetType)
 
self.SetDisabled = SetDisabled
 
self.frame:SetScript("OnEnter", OnEnter)
self.frame:SetScript("OnLeave", OnLeave)
 
self.text:SetTextColor(1, 1, 0)
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
end
 
-- Item: Execute
-- A simple button
do
local widgetType = "Dropdown-Item-Execute"
local widgetVersion = 1
 
local function Frame_OnClick(this, button)
local self = this.obj
if self.disabled then return end
self:Fire("OnClick")
if self.pullout then
self.pullout:Close()
end
end
 
local function Constructor()
local self = ItemBase.Create(widgetType)
 
self.frame:SetScript("OnClick", Frame_OnClick)
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
end
 
-- Item: Toggle
-- Some sort of checkbox for dropdown menus.
-- Does not close the pullout on click.
do
local widgetType = "Dropdown-Item-Toggle"
local widgetVersion = 3
 
local function UpdateToggle(self)
if self.value then
self.check:Show()
else
self.check:Hide()
end
end
 
local function OnRelease(self)
ItemBase.OnRelease(self)
self:SetValue(nil)
end
 
local function Frame_OnClick(this, button)
local self = this.obj
if self.disabled then return end
self.value = not self.value
if self.value then
PlaySound("igMainMenuOptionCheckBoxOn")
else
PlaySound("igMainMenuOptionCheckBoxOff")
end
UpdateToggle(self)
self:Fire("OnValueChanged", self.value)
end
 
-- exported
local function SetValue(self, value)
self.value = value
UpdateToggle(self)
end
 
-- exported
local function GetValue(self)
return self.value
end
 
local function Constructor()
local self = ItemBase.Create(widgetType)
 
self.frame:SetScript("OnClick", Frame_OnClick)
 
self.SetValue = SetValue
self.GetValue = GetValue
self.OnRelease = OnRelease
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
end
 
-- Item: Menu
-- Shows a submenu on mouse over
-- Does not close the pullout on click
do
local widgetType = "Dropdown-Item-Menu"
local widgetVersion = 2
 
local function OnEnter(this)
local self = this.obj
self:Fire("OnEnter")
 
if self.specialOnEnter then
self.specialOnEnter(self)
end
 
self.highlight:Show()
 
if not self.disabled and self.submenu then
self.submenu:Open("TOPLEFT", self.frame, "TOPRIGHT", self.pullout:GetRightBorderWidth(), 0, self.frame:GetFrameLevel() + 100)
end
end
 
local function OnHide(this)
local self = this.obj
if self.submenu then
self.submenu:Close()
end
end
 
-- exported
local function SetMenu(self, menu)
assert(menu.type == "Dropdown-Pullout")
self.submenu = menu
end
 
-- exported
local function CloseMenu(self)
self.submenu:Close()
end
 
local function Constructor()
local self = ItemBase.Create(widgetType)
 
self.sub:Show()
 
self.frame:SetScript("OnEnter", OnEnter)
self.frame:SetScript("OnHide", OnHide)
 
self.SetMenu = SetMenu
self.CloseMenu = CloseMenu
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
end
 
-- Item: Separator
-- A single line to separate items
do
local widgetType = "Dropdown-Item-Separator"
local widgetVersion = 1
 
-- exported, override
local function SetDisabled(self, disabled)
ItemBase.SetDisabled(self, disabled)
self.useHighlight = false
end
 
local function Constructor()
local self = ItemBase.Create(widgetType)
 
self.SetDisabled = SetDisabled
 
local line = self.frame:CreateTexture(nil, "OVERLAY")
line:SetHeight(1)
line:SetTexture(.5, .5, .5)
line:SetPoint("LEFT", self.frame, "LEFT", 10, 0)
line:SetPoint("RIGHT", self.frame, "RIGHT", -10, 0)
 
self.text:Hide()
 
self.useHighlight = false
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
end
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIWidget-Button.lua New file
0,0 → 1,92
--[[-----------------------------------------------------------------------------
Button Widget
Graphical Button.
-------------------------------------------------------------------------------]]
local Type, Version = "Button", 20
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local pairs = pairs
 
-- WoW APIs
local _G = _G
local PlaySound, CreateFrame, UIParent = PlaySound, CreateFrame, UIParent
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function Button_OnClick(frame, ...)
PlaySound("igMainMenuOption")
frame.obj:Fire("OnClick", ...)
AceGUI:ClearFocus()
end
 
local function Control_OnEnter(frame)
frame.obj:Fire("OnEnter")
end
 
local function Control_OnLeave(frame)
frame.obj:Fire("OnLeave")
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
-- restore default values
self:SetHeight(24)
self:SetWidth(200)
self:SetDisabled(false)
self:SetText()
end,
 
-- ["OnRelease"] = nil,
 
["SetText"] = function(self, text)
self.text:SetText(text)
end,
 
["SetDisabled"] = function(self, disabled)
self.disabled = disabled
if disabled then
self.frame:Disable()
else
self.frame:Enable()
end
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local function Constructor()
local name = "AceGUI30Button" .. AceGUI:GetNextWidgetNum(Type)
local frame = CreateFrame("Button", name, UIParent, "UIPanelButtonTemplate2")
frame:Hide()
 
frame:EnableMouse(true)
frame:SetScript("OnClick", Button_OnClick)
frame:SetScript("OnEnter", Control_OnEnter)
frame:SetScript("OnLeave", Control_OnLeave)
 
local text = frame:GetFontString()
text:ClearAllPoints()
text:SetPoint("TOPLEFT", 15, -1)
text:SetPoint("BOTTOMRIGHT", -15, 1)
text:SetJustifyV("MIDDLE")
 
local widget = {
text = text,
frame = frame,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
 
return AceGUI:RegisterAsWidget(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/widgets/AceGUIContainer-TreeGroup.lua New file
0,0 → 1,670
--[[-----------------------------------------------------------------------------
TreeGroup Container
Container that uses a tree control to switch between groups.
-------------------------------------------------------------------------------]]
local Type, Version = "TreeGroup", 30
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local next, pairs, ipairs, assert, type = next, pairs, ipairs, assert, type
local math_min, math_max, floor = math.min, math.max, floor
local select, tremove, unpack = select, table.remove, unpack
 
-- WoW APIs
local CreateFrame, UIParent = CreateFrame, UIParent
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: GameTooltip, FONT_COLOR_CODE_CLOSE
 
-- Recycling functions
local new, del
do
local pool = setmetatable({},{__mode='k'})
function new()
local t = next(pool)
if t then
pool[t] = nil
return t
else
return {}
end
end
function del(t)
for k in pairs(t) do
t[k] = nil
end
pool[t] = true
end
end
 
local DEFAULT_TREE_WIDTH = 175
local DEFAULT_TREE_SIZABLE = true
 
--[[-----------------------------------------------------------------------------
Support functions
-------------------------------------------------------------------------------]]
local function GetButtonUniqueValue(line)
local parent = line.parent
if parent and parent.value then
return GetButtonUniqueValue(parent).."\001"..line.value
else
return line.value
end
end
 
local function UpdateButton(button, treeline, selected, canExpand, isExpanded)
local self = button.obj
local toggle = button.toggle
local frame = self.frame
local text = treeline.text or ""
local icon = treeline.icon
local iconCoords = treeline.iconCoords
local level = treeline.level
local value = treeline.value
local uniquevalue = treeline.uniquevalue
local disabled = treeline.disabled
 
button.treeline = treeline
button.value = value
button.uniquevalue = uniquevalue
if selected then
button:LockHighlight()
button.selected = true
else
button:UnlockHighlight()
button.selected = false
end
local normalTexture = button:GetNormalTexture()
local line = button.line
button.level = level
if ( level == 1 ) then
button:SetNormalFontObject("GameFontNormal")
button:SetHighlightFontObject("GameFontHighlight")
button.text:SetPoint("LEFT", (icon and 16 or 0) + 8, 2)
else
button:SetNormalFontObject("GameFontHighlightSmall")
button:SetHighlightFontObject("GameFontHighlightSmall")
button.text:SetPoint("LEFT", (icon and 16 or 0) + 8 * level, 2)
end
 
if disabled then
button:EnableMouse(false)
button.text:SetText("|cff808080"..text..FONT_COLOR_CODE_CLOSE)
else
button.text:SetText(text)
button:EnableMouse(true)
end
 
if icon then
button.icon:SetTexture(icon)
button.icon:SetPoint("LEFT", 8 * level, (level == 1) and 0 or 1)
else
button.icon:SetTexture(nil)
end
 
if iconCoords then
button.icon:SetTexCoord(unpack(iconCoords))
else
button.icon:SetTexCoord(0, 1, 0, 1)
end
 
if canExpand then
if not isExpanded then
toggle:SetNormalTexture("Interface\\Buttons\\UI-PlusButton-UP")
toggle:SetPushedTexture("Interface\\Buttons\\UI-PlusButton-DOWN")
else
toggle:SetNormalTexture("Interface\\Buttons\\UI-MinusButton-UP")
toggle:SetPushedTexture("Interface\\Buttons\\UI-MinusButton-DOWN")
end
toggle:Show()
else
toggle:Hide()
end
end
 
local function ShouldDisplayLevel(tree)
local result = false
for k, v in ipairs(tree) do
if v.children == nil and v.visible ~= false then
result = true
elseif v.children then
result = result or ShouldDisplayLevel(v.children)
end
if result then return result end
end
return false
end
 
local function addLine(self, v, tree, level, parent)
local line = new()
line.value = v.value
line.text = v.text
line.icon = v.icon
line.iconCoords = v.iconCoords
line.disabled = v.disabled
line.tree = tree
line.level = level
line.parent = parent
line.visible = v.visible
line.uniquevalue = GetButtonUniqueValue(line)
if v.children then
line.hasChildren = true
else
line.hasChildren = nil
end
self.lines[#self.lines+1] = line
return line
end
 
--fire an update after one frame to catch the treeframes height
local function FirstFrameUpdate(frame)
local self = frame.obj
frame:SetScript("OnUpdate", nil)
self:RefreshTree()
end
 
local function BuildUniqueValue(...)
local n = select('#', ...)
if n == 1 then
return ...
else
return (...).."\001"..BuildUniqueValue(select(2,...))
end
end
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function Expand_OnClick(frame)
local button = frame.button
local self = button.obj
local status = (self.status or self.localstatus).groups
status[button.uniquevalue] = not status[button.uniquevalue]
self:RefreshTree()
end
 
local function Button_OnClick(frame)
local self = frame.obj
self:Fire("OnClick", frame.uniquevalue, frame.selected)
if not frame.selected then
self:SetSelected(frame.uniquevalue)
frame.selected = true
frame:LockHighlight()
self:RefreshTree()
end
AceGUI:ClearFocus()
end
 
local function Button_OnDoubleClick(button)
local self = button.obj
local status = self.status or self.localstatus
local status = (self.status or self.localstatus).groups
status[button.uniquevalue] = not status[button.uniquevalue]
self:RefreshTree()
end
 
local function Button_OnEnter(frame)
local self = frame.obj
self:Fire("OnButtonEnter", frame.uniquevalue, frame)
 
if self.enabletooltips then
GameTooltip:SetOwner(frame, "ANCHOR_NONE")
GameTooltip:SetPoint("LEFT",frame,"RIGHT")
GameTooltip:SetText(frame.text:GetText() or "", 1, .82, 0, 1)
 
GameTooltip:Show()
end
end
 
local function Button_OnLeave(frame)
local self = frame.obj
self:Fire("OnButtonLeave", frame.uniquevalue, frame)
 
if self.enabletooltips then
GameTooltip:Hide()
end
end
 
local function OnScrollValueChanged(frame, value)
if frame.obj.noupdate then return end
local self = frame.obj
local status = self.status or self.localstatus
status.scrollvalue = value
self:RefreshTree()
AceGUI:ClearFocus()
end
 
local function Tree_OnSizeChanged(frame)
frame.obj:RefreshTree()
end
 
local function Tree_OnMouseWheel(frame, delta)
local self = frame.obj
if self.showscroll then
local scrollbar = self.scrollbar
local min, max = scrollbar:GetMinMaxValues()
local value = scrollbar:GetValue()
local newvalue = math_min(max,math_max(min,value - delta))
if value ~= newvalue then
scrollbar:SetValue(newvalue)
end
end
end
 
local function Dragger_OnLeave(frame)
frame:SetBackdropColor(1, 1, 1, 0)
end
 
local function Dragger_OnEnter(frame)
frame:SetBackdropColor(1, 1, 1, 0.8)
end
 
local function Dragger_OnMouseDown(frame)
local treeframe = frame:GetParent()
treeframe:StartSizing("RIGHT")
end
 
local function Dragger_OnMouseUp(frame)
local treeframe = frame:GetParent()
local self = treeframe.obj
local frame = treeframe:GetParent()
treeframe:StopMovingOrSizing()
--treeframe:SetScript("OnUpdate", nil)
treeframe:SetUserPlaced(false)
--Without this :GetHeight will get stuck on the current height, causing the tree contents to not resize
treeframe:SetHeight(0)
treeframe:SetPoint("TOPLEFT", frame, "TOPLEFT",0,0)
treeframe:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT",0,0)
 
local status = self.status or self.localstatus
status.treewidth = treeframe:GetWidth()
 
treeframe.obj:Fire("OnTreeResize",treeframe:GetWidth())
-- recalculate the content width
treeframe.obj:OnWidthSet(status.fullwidth)
-- update the layout of the content
treeframe.obj:DoLayout()
end
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetTreeWidth(DEFAULT_TREE_WIDTH, DEFAULT_TREE_SIZABLE)
self:EnableButtonTooltips(true)
end,
 
["OnRelease"] = function(self)
self.status = nil
for k, v in pairs(self.localstatus) do
if k == "groups" then
for k2 in pairs(v) do
v[k2] = nil
end
else
self.localstatus[k] = nil
end
end
self.localstatus.scrollvalue = 0
self.localstatus.treewidth = DEFAULT_TREE_WIDTH
self.localstatus.treesizable = DEFAULT_TREE_SIZABLE
end,
 
["EnableButtonTooltips"] = function(self, enable)
self.enabletooltips = enable
end,
 
["CreateButton"] = function(self)
local num = AceGUI:GetNextWidgetNum("TreeGroupButton")
local button = CreateFrame("Button", ("AceGUI30TreeButton%d"):format(num), self.treeframe, "OptionsListButtonTemplate")
button.obj = self
 
local icon = button:CreateTexture(nil, "OVERLAY")
icon:SetWidth(14)
icon:SetHeight(14)
button.icon = icon
 
button:SetScript("OnClick",Button_OnClick)
button:SetScript("OnDoubleClick", Button_OnDoubleClick)
button:SetScript("OnEnter",Button_OnEnter)
button:SetScript("OnLeave",Button_OnLeave)
 
button.toggle.button = button
button.toggle:SetScript("OnClick",Expand_OnClick)
 
return button
end,
 
["SetStatusTable"] = function(self, status)
assert(type(status) == "table")
self.status = status
if not status.groups then
status.groups = {}
end
if not status.scrollvalue then
status.scrollvalue = 0
end
if not status.treewidth then
status.treewidth = DEFAULT_TREE_WIDTH
end
if 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
["SetTree"] = function(self, tree, filter)
self.filter = filter
if tree then
assert(type(tree) == "table")
end
self.tree = tree
self:RefreshTree()
end,
 
["BuildLevel"] = function(self, tree, level, parent)
local groups = (self.status or self.localstatus).groups
local hasChildren = self.hasChildren
 
for i, v in ipairs(tree) do
if v.children then
if not self.filter or ShouldDisplayLevel(v.children) then
local line = addLine(self, v, tree, level, parent)
if groups[line.uniquevalue] then
self:BuildLevel(v.children, level+1, line)
end
end
elseif v.visible ~= false or not self.filter then
addLine(self, v, tree, level, parent)
end
end
end,
 
["RefreshTree"] = function(self)
local buttons = self.buttons
local lines = self.lines
 
for i, v in ipairs(buttons) do
v:Hide()
end
while lines[1] do
local t = tremove(lines)
for k in pairs(t) do
t[k] = nil
end
del(t)
end
 
if not self.tree then return end
--Build the list of visible entries from the tree and status tables
local status = self.status or self.localstatus
local groupstatus = status.groups
local tree = self.tree
 
local treeframe = self.treeframe
 
self:BuildLevel(tree, 1)
 
local numlines = #lines
 
local maxlines = (floor(((self.treeframe:GetHeight()or 0) - 20 ) / 18))
 
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,
 
["SetSelected"] = function(self, value)
local status = self.status or self.localstatus
if status.selected ~= value then
status.selected = value
self:Fire("OnGroupSelected", value)
end
end,
 
["Select"] = function(self, uniquevalue, ...)
self.filter = false
local status = self.status or self.localstatus
local groups = status.groups
for i = 1, select('#', ...) do
groups[BuildUniqueValue(select(i, ...))] = true
end
status.selected = uniquevalue
self:RefreshTree()
self:Fire("OnGroupSelected", uniquevalue)
end,
 
["SelectByPath"] = function(self, ...)
self:Select(BuildUniqueValue(...), ...)
end,
 
["SelectByValue"] = function(self, uniquevalue)
self:Select(uniquevalue, ("\001"):split(uniquevalue))
end,
 
["ShowScroll"] = function(self, show)
self.showscroll = show
if show then
self.scrollbar:Show()
if self.buttons[1] then
self.buttons[1]:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",-22,-10)
end
else
self.scrollbar:Hide()
if self.buttons[1] then
self.buttons[1]:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",0,-10)
end
end
end,
 
["OnWidthSet"] = function(self, width)
local content = self.content
local treeframe = self.treeframe
local status = self.status or self.localstatus
status.fullwidth = width
 
local contentwidth = width - status.treewidth - 20
if contentwidth < 0 then
contentwidth = 0
end
content:SetWidth(contentwidth)
content.width = contentwidth
 
local maxtreewidth = math_min(400, width - 50)
 
if maxtreewidth > 100 and status.treewidth > maxtreewidth then
self:SetTreeWidth(maxtreewidth, status.treesizable)
end
treeframe:SetMaxResize(maxtreewidth, 1600)
end,
 
["OnHeightSet"] = function(self, height)
local content = self.content
local contentheight = height - 20
if contentheight < 0 then
contentheight = 0
end
content:SetHeight(contentheight)
content.height = contentheight
end,
 
["SetTreeWidth"] = function(self, treewidth, resizable)
if not resizable then
if type(treewidth) == 'number' then
resizable = false
elseif type(treewidth) == 'boolean' then
resizable = treewidth
treewidth = DEFAULT_TREE_WIDTH
else
resizable = false
treewidth = DEFAULT_TREE_WIDTH
end
end
self.treeframe:SetWidth(treewidth)
self.dragger:EnableMouse(resizable)
 
local status = self.status or self.localstatus
status.treewidth = treewidth
status.treesizable = resizable
 
-- recalculate the content width
if status.fullwidth then
self:OnWidthSet(status.fullwidth)
end
end,
 
["LayoutFinished"] = function(self, width, height)
if self.noAutoHeight then return end
self:SetHeight((height or 0) + 20)
end
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local PaneBackdrop = {
bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
tile = true, tileSize = 16, edgeSize = 16,
insets = { left = 3, right = 3, top = 5, bottom = 3 }
}
 
local DraggerBackdrop = {
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
edgeFile = nil,
tile = true, tileSize = 16, edgeSize = 0,
insets = { left = 3, right = 3, top = 7, bottom = 7 }
}
 
local function Constructor()
local num = AceGUI:GetNextWidgetNum(Type)
local frame = CreateFrame("Frame", nil, UIParent)
 
local treeframe = CreateFrame("Frame", nil, frame)
treeframe:SetPoint("TOPLEFT")
treeframe:SetPoint("BOTTOMLEFT")
treeframe:SetWidth(DEFAULT_TREE_WIDTH)
treeframe:EnableMouseWheel(true)
treeframe:SetBackdrop(PaneBackdrop)
treeframe:SetBackdropColor(0.1, 0.1, 0.1, 0.5)
treeframe:SetBackdropBorderColor(0.4, 0.4, 0.4)
treeframe:SetResizable(true)
treeframe:SetMinResize(100, 1)
treeframe:SetMaxResize(400, 1600)
treeframe:SetScript("OnUpdate", FirstFrameUpdate)
treeframe:SetScript("OnSizeChanged", Tree_OnSizeChanged)
treeframe:SetScript("OnMouseWheel", Tree_OnMouseWheel)
 
local dragger = CreateFrame("Frame", nil, treeframe)
dragger:SetWidth(8)
dragger:SetPoint("TOP", treeframe, "TOPRIGHT")
dragger:SetPoint("BOTTOM", treeframe, "BOTTOMRIGHT")
dragger:SetBackdrop(DraggerBackdrop)
dragger:SetBackdropColor(1, 1, 1, 0)
dragger:SetScript("OnEnter", Dragger_OnEnter)
dragger:SetScript("OnLeave", Dragger_OnLeave)
dragger:SetScript("OnMouseDown", Dragger_OnMouseDown)
dragger:SetScript("OnMouseUp", Dragger_OnMouseUp)
 
local scrollbar = CreateFrame("Slider", ("AceConfigDialogTreeGroup%dScrollBar"):format(num), treeframe, "UIPanelScrollBarTemplate")
scrollbar:SetScript("OnValueChanged", nil)
scrollbar:SetPoint("TOPRIGHT", -10, -26)
scrollbar:SetPoint("BOTTOMRIGHT", -10, 26)
scrollbar:SetMinMaxValues(0,0)
scrollbar:SetValueStep(1)
scrollbar:SetValue(0)
scrollbar:SetWidth(16)
scrollbar:SetScript("OnValueChanged", OnScrollValueChanged)
 
local scrollbg = scrollbar:CreateTexture(nil, "BACKGROUND")
scrollbg:SetAllPoints(scrollbar)
scrollbg:SetTexture(0,0,0,0.4)
 
local border = CreateFrame("Frame",nil,frame)
border:SetPoint("TOPLEFT", treeframe, "TOPRIGHT")
border:SetPoint("BOTTOMRIGHT")
border:SetBackdrop(PaneBackdrop)
border:SetBackdropColor(0.1, 0.1, 0.1, 0.5)
border:SetBackdropBorderColor(0.4, 0.4, 0.4)
 
--Container Support
local content = CreateFrame("Frame", nil, border)
content:SetPoint("TOPLEFT", 10, -10)
content:SetPoint("BOTTOMRIGHT", -10, 10)
 
local widget = {
frame = frame,
lines = {},
levels = {},
buttons = {},
hasChildren = {},
localstatus = { groups = {}, scrollvalue = 0 },
filter = false,
treeframe = treeframe,
dragger = dragger,
scrollbar = scrollbar,
border = border,
content = content,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
treeframe.obj, dragger.obj, scrollbar.obj = widget, widget, widget
 
return AceGUI:RegisterAsContainer(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
mNameplates/Libs/AceGUI-3.0/AceGUI-3.0.xml New file
0,0 → 1,28
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Script file="AceGUI-3.0.lua"/>
<!-- Container -->
<Script file="widgets\AceGUIContainer-BlizOptionsGroup.lua"/>
<Script file="widgets\AceGUIContainer-DropDownGroup.lua"/>
<Script file="widgets\AceGUIContainer-Frame.lua"/>
<Script file="widgets\AceGUIContainer-InlineGroup.lua"/>
<Script file="widgets\AceGUIContainer-ScrollFrame.lua"/>
<Script file="widgets\AceGUIContainer-SimpleGroup.lua"/>
<Script file="widgets\AceGUIContainer-TabGroup.lua"/>
<Script file="widgets\AceGUIContainer-TreeGroup.lua"/>
<Script file="widgets\AceGUIContainer-Window.lua"/>
<!-- Widgets -->
<Script file="widgets\AceGUIWidget-Button.lua"/>
<Script file="widgets\AceGUIWidget-CheckBox.lua"/>
<Script file="widgets\AceGUIWidget-ColorPicker.lua"/>
<Script file="widgets\AceGUIWidget-DropDown.lua"/>
<Script file="widgets\AceGUIWidget-DropDown-Items.lua"/>
<Script file="widgets\AceGUIWidget-EditBox.lua"/>
<Script file="widgets\AceGUIWidget-Heading.lua"/>
<Script file="widgets\AceGUIWidget-Icon.lua"/>
<Script file="widgets\AceGUIWidget-InteractiveLabel.lua"/>
<Script file="widgets\AceGUIWidget-Keybinding.lua"/>
<Script file="widgets\AceGUIWidget-Label.lua"/>
<Script file="widgets\AceGUIWidget-MultiLineEditBox.lua"/>
<Script file="widgets\AceGUIWidget-Slider.lua"/>
</Ui>
mNameplates/Libs/AceGUI-3.0/AceGUI-3.0.lua New file
0,0 → 1,805
--- **AceGUI-3.0** provides access to numerous widgets which can be used to create GUIs.
-- AceGUI is used by AceConfigDialog to create the option GUIs, but you can use it by itself
-- to create any custom GUI. There are more extensive examples in the test suite in the Ace3
-- stand-alone distribution.
--
-- **Note**: When using AceGUI-3.0 directly, please do not modify the frames of the widgets directly,
-- as any "unknown" change to the widgets will cause addons that get your widget out of the widget pool
-- to misbehave. If you think some part of a widget should be modifiable, please open a ticket, and we"ll
-- implement a proper API to modify it.
-- @usage
-- local AceGUI = LibStub("AceGUI-3.0")
-- -- Create a container frame
-- local f = AceGUI:Create("Frame")
-- f:SetCallback("OnClose",function(widget) AceGUI:Release(widget) end)
-- f:SetTitle("AceGUI-3.0 Example")
-- f:SetStatusText("Status Bar")
-- f:SetLayout("Flow")
-- -- Create a button
-- local btn = AceGUI:Create("Button")
-- btn:SetWidth(170)
-- btn:SetText("Button !")
-- btn:SetCallback("OnClick", function() print("Click!") end)
-- -- Add the button to the container
-- f:AddChild(btn)
-- @class file
-- @name AceGUI-3.0
-- @release $Id: AceGUI-3.0.lua 924 2010-05-13 15:12:20Z nevcairiel $
local ACEGUI_MAJOR, ACEGUI_MINOR = "AceGUI-3.0", 33
local AceGUI, oldminor = LibStub:NewLibrary(ACEGUI_MAJOR, ACEGUI_MINOR)
 
if not AceGUI then return end -- No upgrade needed
 
-- Lua APIs
local tconcat, tremove, tinsert = table.concat, table.remove, table.insert
local select, pairs, next, type = select, pairs, next, type
local error, assert, loadstring = error, assert, loadstring
local setmetatable, rawget, rawset = setmetatable, rawget, rawset
local math_max = math.max
 
-- WoW APIs
local UIParent = UIParent
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: geterrorhandler, LibStub
 
--local con = LibStub("AceConsole-3.0",true)
 
AceGUI.WidgetRegistry = AceGUI.WidgetRegistry or {}
AceGUI.LayoutRegistry = AceGUI.LayoutRegistry or {}
AceGUI.WidgetBase = AceGUI.WidgetBase or {}
AceGUI.WidgetContainerBase = AceGUI.WidgetContainerBase or {}
AceGUI.WidgetVersions = AceGUI.WidgetVersions or {}
 
-- local upvalues
local WidgetRegistry = AceGUI.WidgetRegistry
local LayoutRegistry = AceGUI.LayoutRegistry
local WidgetVersions = AceGUI.WidgetVersions
 
--[[
xpcall safecall implementation
]]
local xpcall = xpcall
 
local function errorhandler(err)
return geterrorhandler()(err)
end
 
local function CreateDispatcher(argCount)
local code = [[
local xpcall, eh = ...
local method, ARGS
local function call() return method(ARGS) end
 
local function dispatch(func, ...)
method = func
if not method then return end
ARGS = ...
return xpcall(call, eh)
end
 
return dispatch
]]
 
local ARGS = {}
for i = 1, argCount do ARGS[i] = "arg"..i end
code = code:gsub("ARGS", tconcat(ARGS, ", "))
return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(xpcall, errorhandler)
end
 
local Dispatchers = setmetatable({}, {__index=function(self, argCount)
local dispatcher = CreateDispatcher(argCount)
rawset(self, argCount, dispatcher)
return dispatcher
end})
Dispatchers[0] = function(func)
return xpcall(func, errorhandler)
end
 
local function safecall(func, ...)
return Dispatchers[select("#", ...)](func, ...)
end
 
-- Recycling functions
local newWidget, delWidget
do
-- Version Upgrade in Minor 29
-- Internal Storage of the objects changed, from an array table
-- to a hash table, and additionally we introduced versioning on
-- the widgets which would discard all widgets from a pre-29 version
-- anyway, so we just clear the storage now, and don't try to
-- convert the storage tables to the new format.
-- This should generally not cause *many* widgets to end up in trash,
-- since once dialogs are opened, all addons should be loaded already
-- and AceGUI should be on the latest version available on the users
-- setup.
-- -- nevcairiel - Nov 2nd, 2009
if oldminor and oldminor < 29 and AceGUI.objPools then
AceGUI.objPools = nil
end
 
AceGUI.objPools = AceGUI.objPools or {}
local objPools = AceGUI.objPools
--Returns a new instance, if none are available either returns a new table or calls the given contructor
function newWidget(type)
if not WidgetRegistry[type] then
error("Attempt to instantiate unknown widget type", 2)
end
 
if not objPools[type] then
objPools[type] = {}
end
 
local newObj = next(objPools[type])
if not newObj then
newObj = WidgetRegistry[type]()
newObj.AceGUIWidgetVersion = WidgetVersions[type]
else
objPools[type][newObj] = nil
-- if the widget is older then the latest, don't even try to reuse it
-- just forget about it, and grab a new one.
if not newObj.AceGUIWidgetVersion or newObj.AceGUIWidgetVersion < WidgetVersions[type] then
return newWidget(type)
end
end
return newObj
end
-- Releases an instance to the Pool
function delWidget(obj,type)
if not objPools[type] then
objPools[type] = {}
end
if objPools[type][obj] then
error("Attempt to Release Widget that is already released", 2)
end
objPools[type][obj] = true
end
end
 
 
-------------------
-- API Functions --
-------------------
 
-- Gets a widget Object
 
--- Create a new Widget of the given type.
-- This function will instantiate a new widget (or use one from the widget pool), and call the
-- OnAcquire function on it, before returning.
-- @param type The type of the widget.
-- @return The newly created widget.
function AceGUI:Create(type)
if WidgetRegistry[type] then
local widget = newWidget(type)
 
if rawget(widget, "Acquire") then
widget.OnAcquire = widget.Acquire
widget.Acquire = nil
elseif rawget(widget, "Aquire") then
widget.OnAcquire = widget.Aquire
widget.Aquire = nil
end
 
if rawget(widget, "Release") then
widget.OnRelease = rawget(widget, "Release")
widget.Release = nil
end
 
if widget.OnAcquire then
widget:OnAcquire()
else
error(("Widget type %s doesn't supply an OnAcquire Function"):format(type))
end
-- Set the default Layout ("List")
safecall(widget.SetLayout, widget, "List")
safecall(widget.ResumeLayout, widget)
return widget
end
end
 
--- Releases a widget Object.
-- This function calls OnRelease on the widget and places it back in the widget pool.
-- Any data on the widget is being erased, and the widget will be hidden.\\
-- If this widget is a Container-Widget, all of its Child-Widgets will be releases as well.
-- @param widget The widget to release
function AceGUI:Release(widget)
safecall(widget.PauseLayout, widget)
widget:Fire("OnRelease")
safecall(widget.ReleaseChildren, widget)
 
if widget.OnRelease then
widget:OnRelease()
-- else
-- error(("Widget type %s doesn't supply an OnRelease Function"):format(widget.type))
end
for k in pairs(widget.userdata) do
widget.userdata[k] = nil
end
for k in pairs(widget.events) do
widget.events[k] = nil
end
widget.width = nil
widget.relWidth = nil
widget.height = nil
widget.relHeight = nil
widget.noAutoHeight = nil
widget.frame:ClearAllPoints()
widget.frame:Hide()
widget.frame:SetParent(UIParent)
widget.frame.width = nil
widget.frame.height = nil
if widget.content then
widget.content.width = nil
widget.content.height = nil
end
delWidget(widget, widget.type)
end
 
-----------
-- Focus --
-----------
 
 
--- Called when a widget has taken focus.
-- e.g. Dropdowns opening, Editboxes gaining kb focus
-- @param widget The widget that should be focused
function AceGUI:SetFocus(widget)
if self.FocusedWidget and self.FocusedWidget ~= widget then
safecall(self.FocusedWidget.ClearFocus, self.FocusedWidget)
end
self.FocusedWidget = widget
end
 
 
--- Called when something has happened that could cause widgets with focus to drop it
-- e.g. titlebar of a frame being clicked
function AceGUI:ClearFocus()
if self.FocusedWidget then
safecall(self.FocusedWidget.ClearFocus, self.FocusedWidget)
self.FocusedWidget = nil
end
end
 
-------------
-- Widgets --
-------------
--[[
Widgets must provide the following functions
OnAcquire() - Called when the object is acquired, should set everything to a default hidden state
 
And the following members
frame - the frame or derivitive object that will be treated as the widget for size and anchoring purposes
type - the type of the object, same as the name given to :RegisterWidget()
 
Widgets contain a table called userdata, this is a safe place to store data associated with the wigdet
It will be cleared automatically when a widget is released
Placing values directly into a widget object should be avoided
 
If the Widget can act as a container for other Widgets the following
content - frame or derivitive that children will be anchored to
 
The Widget can supply the following Optional Members
:OnRelease() - Called when the object is Released, should remove any additional anchors and clear any data
:OnWidthSet(width) - Called when the width of the widget is changed
:OnHeightSet(height) - Called when the height of the widget is changed
Widgets should not use the OnSizeChanged events of thier frame or content members, use these methods instead
AceGUI already sets a handler to the event
:LayoutFinished(width, height) - called after a layout has finished, the width and height will be the width and height of the
area used for controls. These can be nil if the layout used the existing size to layout the controls.
 
]]
 
--------------------------
-- Widget Base Template --
--------------------------
do
local WidgetBase = AceGUI.WidgetBase
 
WidgetBase.SetParent = function(self, parent)
local frame = self.frame
frame:SetParent(nil)
frame:SetParent(parent.content)
self.parent = parent
end
 
WidgetBase.SetCallback = function(self, name, func)
if type(func) == "function" then
self.events[name] = func
end
end
 
WidgetBase.Fire = function(self, name, ...)
if self.events[name] then
local success, ret = safecall(self.events[name], self, name, ...)
if success then
return ret
end
end
end
 
WidgetBase.SetWidth = function(self, width)
self.frame:SetWidth(width)
self.frame.width = width
if self.OnWidthSet then
self:OnWidthSet(width)
end
end
 
WidgetBase.SetRelativeWidth = function(self, width)
if width <= 0 or width > 1 then
error(":SetRelativeWidth(width): Invalid relative width.", 2)
end
self.relWidth = width
self.width = "relative"
end
 
WidgetBase.SetHeight = function(self, height)
self.frame:SetHeight(height)
self.frame.height = height
if self.OnHeightSet then
self:OnHeightSet(height)
end
end
 
--[[ WidgetBase.SetRelativeHeight = function(self, height)
if height <= 0 or height > 1 then
error(":SetRelativeHeight(height): Invalid relative height.", 2)
end
self.relHeight = height
self.height = "relative"
end ]]
 
WidgetBase.IsVisible = function(self)
return self.frame:IsVisible()
end
 
WidgetBase.IsShown= function(self)
return self.frame:IsShown()
end
 
WidgetBase.Release = function(self)
AceGUI:Release(self)
end
 
WidgetBase.SetPoint = function(self, ...)
return self.frame:SetPoint(...)
end
 
WidgetBase.ClearAllPoints = function(self)
return self.frame:ClearAllPoints()
end
 
WidgetBase.GetNumPoints = function(self)
return self.frame:GetNumPoints()
end
 
WidgetBase.GetPoint = function(self, ...)
return self.frame:GetPoint(...)
end
 
WidgetBase.GetUserDataTable = function(self)
return self.userdata
end
 
WidgetBase.SetUserData = function(self, key, value)
self.userdata[key] = value
end
 
WidgetBase.GetUserData = function(self, key)
return self.userdata[key]
end
 
WidgetBase.IsFullHeight = function(self)
return self.height == "fill"
end
 
WidgetBase.SetFullHeight = function(self, isFull)
if isFull then
self.height = "fill"
else
self.height = nil
end
end
 
WidgetBase.IsFullWidth = function(self)
return self.width == "fill"
end
 
WidgetBase.SetFullWidth = function(self, isFull)
if isFull then
self.width = "fill"
else
self.width = nil
end
end
 
-- local function LayoutOnUpdate(this)
-- this:SetScript("OnUpdate",nil)
-- this.obj:PerformLayout()
-- end
 
local WidgetContainerBase = AceGUI.WidgetContainerBase
 
WidgetContainerBase.PauseLayout = function(self)
self.LayoutPaused = true
end
 
WidgetContainerBase.ResumeLayout = function(self)
self.LayoutPaused = nil
end
 
WidgetContainerBase.PerformLayout = function(self)
if self.LayoutPaused then
return
end
safecall(self.LayoutFunc, self.content, self.children)
end
 
--call this function to layout, makes sure layed out objects get a frame to get sizes etc
WidgetContainerBase.DoLayout = function(self)
self:PerformLayout()
-- if not self.parent then
-- self.frame:SetScript("OnUpdate", LayoutOnUpdate)
-- end
end
 
WidgetContainerBase.AddChild = function(self, child, beforeWidget)
if beforeWidget then
local siblingIndex = 1
for _, widget in pairs(self.children) do
if widget == beforeWidget then
break
end
siblingIndex = siblingIndex + 1
end
tinsert(self.children, siblingIndex, child)
else
tinsert(self.children, child)
end
child:SetParent(self)
child.frame:Show()
self:DoLayout()
end
 
WidgetContainerBase.AddChildren = function(self, ...)
for i = 1, select("#", ...) do
local child = select(i, ...)
tinsert(self.children, child)
child:SetParent(self)
child.frame:Show()
end
self:DoLayout()
end
 
WidgetContainerBase.ReleaseChildren = function(self)
local children = self.children
for i = 1,#children do
AceGUI:Release(children[i])
children[i] = nil
end
end
 
WidgetContainerBase.SetLayout = function(self, Layout)
self.LayoutFunc = AceGUI:GetLayout(Layout)
end
 
WidgetContainerBase.SetAutoAdjustHeight = function(self, adjust)
if adjust then
self.noAutoHeight = nil
else
self.noAutoHeight = true
end
end
 
local function FrameResize(this)
local self = this.obj
if this:GetWidth() and this:GetHeight() then
if self.OnWidthSet then
self:OnWidthSet(this:GetWidth())
end
if self.OnHeightSet then
self:OnHeightSet(this:GetHeight())
end
end
end
 
local function ContentResize(this)
if this:GetWidth() and this:GetHeight() then
this.width = this:GetWidth()
this.height = this:GetHeight()
this.obj:DoLayout()
end
end
 
setmetatable(WidgetContainerBase, {__index=WidgetBase})
 
--One of these function should be called on each Widget Instance as part of its creation process
 
--- Register a widget-class as a container for newly created widgets.
-- @param widget The widget class
function AceGUI:RegisterAsContainer(widget)
widget.children = {}
widget.userdata = {}
widget.events = {}
widget.base = WidgetContainerBase
widget.content.obj = widget
widget.frame.obj = widget
widget.content:SetScript("OnSizeChanged", ContentResize)
widget.frame:SetScript("OnSizeChanged", FrameResize)
setmetatable(widget, {__index = WidgetContainerBase})
widget:SetLayout("List")
return widget
end
 
--- Register a widget-class as a widget.
-- @param widget The widget class
function AceGUI:RegisterAsWidget(widget)
widget.userdata = {}
widget.events = {}
widget.base = WidgetBase
widget.frame.obj = widget
widget.frame:SetScript("OnSizeChanged", FrameResize)
setmetatable(widget, {__index = WidgetBase})
return widget
end
end
 
 
 
 
------------------
-- Widget API --
------------------
 
--- Registers a widget Constructor, this function returns a new instance of the Widget
-- @param Name The name of the widget
-- @param Constructor The widget constructor function
-- @param Version The version of the widget
function AceGUI:RegisterWidgetType(Name, Constructor, Version)
assert(type(Constructor) == "function")
assert(type(Version) == "number")
 
local oldVersion = WidgetVersions[Name]
if oldVersion and oldVersion >= Version then return end
 
WidgetVersions[Name] = Version
WidgetRegistry[Name] = Constructor
end
 
--- Registers a Layout Function
-- @param Name The name of the layout
-- @param LayoutFunc Reference to the layout function
function AceGUI:RegisterLayout(Name, LayoutFunc)
assert(type(LayoutFunc) == "function")
if type(Name) == "string" then
Name = Name:upper()
end
LayoutRegistry[Name] = LayoutFunc
end
 
--- Get a Layout Function from the registry
-- @param Name The name of the layout
function AceGUI:GetLayout(Name)
if type(Name) == "string" then
Name = Name:upper()
end
return LayoutRegistry[Name]
end
 
AceGUI.counts = AceGUI.counts or {}
 
--- A type-based counter to count the number of widgets created.
-- This is used by widgets that require a named frame, e.g. when a Blizzard
-- Template requires it.
-- @param type The widget type
function AceGUI:GetNextWidgetNum(type)
if not self.counts[type] then
self.counts[type] = 0
end
self.counts[type] = self.counts[type] + 1
return self.counts[type]
end
 
--- Return the number of created widgets for this type.
-- In contrast to GetNextWidgetNum, the number is not incremented.
-- @param type The widget type
function AceGUI:GetWidgetCount(type)
return self.counts[type] or 0
end
 
--- Return the version of the currently registered widget type.
-- @param type The widget type
function AceGUI:GetWidgetVersion(type)
return WidgetVersions[type]
end
 
-------------
-- Layouts --
-------------
 
--[[
A Layout is a func that takes 2 parameters
content - the frame that widgets will be placed inside
children - a table containing the widgets to layout
]]
 
-- Very simple Layout, Children are stacked on top of each other down the left side
AceGUI:RegisterLayout("List",
function(content, children)
local height = 0
local width = content.width or content:GetWidth() or 0
for i = 1, #children do
local child = children[i]
 
local frame = child.frame
frame:ClearAllPoints()
frame:Show()
if i == 1 then
frame:SetPoint("TOPLEFT", content)
else
frame:SetPoint("TOPLEFT", children[i-1].frame, "BOTTOMLEFT")
end
 
if child.width == "fill" then
child:SetWidth(width)
frame:SetPoint("RIGHT", content)
 
if child.DoLayout then
child:DoLayout()
end
elseif child.width == "relative" then
child:SetWidth(width * child.relWidth)
 
if child.DoLayout then
child:DoLayout()
end
end
 
height = height + (frame.height or frame:GetHeight() or 0)
end
safecall(content.obj.LayoutFinished, content.obj, nil, height)
end)
 
-- A single control fills the whole content area
AceGUI:RegisterLayout("Fill",
function(content, children)
if children[1] then
children[1]:SetWidth(content:GetWidth() or 0)
children[1]:SetHeight(content:GetHeight() or 0)
children[1].frame:SetAllPoints(content)
children[1].frame:Show()
safecall(content.obj.LayoutFinished, content.obj, nil, children[1].frame:GetHeight())
end
end)
 
AceGUI:RegisterLayout("Flow",
function(content, children)
--used height so far
local height = 0
--width used in the current row
local usedwidth = 0
--height of the current row
local rowheight = 0
local rowoffset = 0
local lastrowoffset
 
local width = content.width or content:GetWidth() or 0
 
--control at the start of the row
local rowstart
local rowstartoffset
local lastrowstart
local isfullheight
 
local frameoffset
local lastframeoffset
local oversize
for i = 1, #children do
local child = children[i]
oversize = nil
local frame = child.frame
local frameheight = frame.height or frame:GetHeight() or 0
local framewidth = frame.width or frame:GetWidth() or 0
lastframeoffset = frameoffset
-- HACK: Why did we set a frameoffset of (frameheight / 2) ?
-- That was moving all widgets half the widgets size down, is that intended?
-- Actually, it seems to be neccessary for many cases, we'll leave it in for now.
-- If widgets seem to anchor weirdly with this, provide a valid alignoffset for them.
-- TODO: Investigate moar!
frameoffset = child.alignoffset or (frameheight / 2)
 
if child.width == "relative" then
framewidth = width * child.relWidth
end
 
frame:Show()
frame:ClearAllPoints()
if i == 1 then
-- anchor the first control to the top left
frame:SetPoint("TOPLEFT", content)
rowheight = frameheight
rowoffset = frameoffset
rowstart = frame
rowstartoffset = frameoffset
usedwidth = framewidth
if usedwidth > width then
oversize = true
end
else
-- if there isn't available width for the control start a new row
-- if a control is "fill" it will be on a row of its own full width
if usedwidth == 0 or ((framewidth) + usedwidth > width) or child.width == "fill" then
if isfullheight then
-- a previous row has already filled the entire height, there's nothing we can usefully do anymore
-- (maybe error/warn about this?)
break
end
--anchor the previous row, we will now know its height and offset
rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -(height + (rowoffset - rowstartoffset) + 3))
height = height + rowheight + 3
--save this as the rowstart so we can anchor it after the row is complete and we have the max height and offset of controls in it
rowstart = frame
rowstartoffset = frameoffset
rowheight = frameheight
rowoffset = frameoffset
usedwidth = framewidth
if usedwidth > width then
oversize = true
end
-- put the control on the current row, adding it to the width and checking if the height needs to be increased
else
--handles cases where the new height is higher than either control because of the offsets
--math.max(rowheight-rowoffset+frameoffset, frameheight-frameoffset+rowoffset)
 
--offset is always the larger of the two offsets
rowoffset = math_max(rowoffset, frameoffset)
rowheight = math_max(rowheight, rowoffset + (frameheight / 2))
 
frame:SetPoint("TOPLEFT", children[i-1].frame, "TOPRIGHT", 0, frameoffset - lastframeoffset)
usedwidth = framewidth + usedwidth
end
end
 
if child.width == "fill" then
child:SetWidth(width)
frame:SetPoint("RIGHT", content)
 
usedwidth = 0
rowstart = frame
rowstartoffset = frameoffset
 
if child.DoLayout then
child:DoLayout()
end
rowheight = frame.height or frame:GetHeight() or 0
rowoffset = child.alignoffset or (rowheight / 2)
rowstartoffset = rowoffset
elseif child.width == "relative" then
child:SetWidth(width * child.relWidth)
 
if child.DoLayout then
child:DoLayout()
end
elseif oversize then
if width > 1 then
frame:SetPoint("RIGHT", content)
end
end
 
if child.height == "fill" then
frame:SetPoint("BOTTOM", content)
isfullheight = true
end
end
 
--anchor the last row, if its full height needs a special case since its height has just been changed by the anchor
if isfullheight then
rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -height)
elseif rowstart then
rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -(height + (rowoffset - rowstartoffset) + 3))
end
 
height = height + rowheight + 3
safecall(content.obj.LayoutFinished, content.obj, nil, height)
end)
mNameplates/Libs/LibSharedMedia-3.0/LibSharedMedia-3.0.lua New file
0,0 → 1,230
--[[
Name: LibSharedMedia-3.0
Revision: $Revision: 58 $
Author: Elkano (elkano@gmx.de)
Inspired By: SurfaceLib by Haste/Otravi (troeks@gmail.com)
Website: http://www.wowace.com/projects/libsharedmedia-3-0/
Description: Shared handling of media data (fonts, sounds, textures, ...) between addons.
Dependencies: LibStub, CallbackHandler-1.0
License: LGPL v2.1
]]
 
local MAJOR, MINOR = "LibSharedMedia-3.0", 90000 + tonumber(("$Revision: 58 $"):match("(%d+)"))
local lib = LibStub:NewLibrary(MAJOR, MINOR)
 
if not lib then return end
 
local _G = getfenv(0)
 
local pairs = _G.pairs
local type = _G.type
 
local band = _G.bit.band
 
local table_insert = _G.table.insert
local table_sort = _G.table.sort
 
local locale = GetLocale()
local locale_is_western
local LOCALE_MASK = 0
lib.LOCALE_BIT_koKR = 1
lib.LOCALE_BIT_ruRU = 2
lib.LOCALE_BIT_zhCN = 4
lib.LOCALE_BIT_zhTW = 8
lib.LOCALE_BIT_western = 128
 
local CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0")
 
lib.callbacks = lib.callbacks or CallbackHandler:New(lib)
 
lib.DefaultMedia = lib.DefaultMedia or {}
lib.MediaList = lib.MediaList or {}
lib.MediaTable = lib.MediaTable or {}
lib.MediaType = lib.MediaType or {}
lib.OverrideMedia = lib.OverrideMedia or {}
 
local defaultMedia = lib.DefaultMedia
local mediaList = lib.MediaList
local mediaTable = lib.MediaTable
local overrideMedia = lib.OverrideMedia
 
 
-- create mediatype constants
lib.MediaType.BACKGROUND = "background" -- background textures
lib.MediaType.BORDER = "border" -- border textures
lib.MediaType.FONT = "font" -- fonts
lib.MediaType.STATUSBAR = "statusbar" -- statusbar textures
lib.MediaType.SOUND = "sound" -- sound files
 
-- populate lib with default Blizzard data
-- BACKGROUND
if not lib.MediaTable.background then lib.MediaTable.background = {} end
lib.MediaTable.background["Blizzard Dialog Background"] = [[Interface\DialogFrame\UI-DialogBox-Background]]
lib.MediaTable.background["Blizzard Low Health"] = [[Interface\FullScreenTextures\LowHealth]]
lib.MediaTable.background["Blizzard Out of Control"] = [[Interface\FullScreenTextures\OutOfControl]]
lib.MediaTable.background["Blizzard Parchment"] = [[Interface\AchievementFrame\UI-Achievement-Parchment-Horizontal]]
lib.MediaTable.background["Blizzard Parchment 2"] = [[Interface\AchievementFrame\UI-Achievement-Parchment]]
lib.MediaTable.background["Blizzard Tabard Background"] = [[Interface\TabardFrame\TabardFrameBackground]]
lib.MediaTable.background["Blizzard Tooltip"] = [[Interface\Tooltips\UI-Tooltip-Background]]
lib.MediaTable.background["Solid"] = [[Interface\Buttons\WHITE8X8]]
 
-- BORDER
if not lib.MediaTable.border then lib.MediaTable.border = {} end
lib.MediaTable.border["None"] = [[Interface\None]]
lib.MediaTable.border["Blizzard Achievement Wood"] = [[Interface\AchievementFrame\UI-Achievement-WoodBorder]]
lib.MediaTable.border["Blizzard Chat Bubble"] = [[Interface\Tooltips\ChatBubble-Backdrop]]
lib.MediaTable.border["Blizzard Dialog"] = [[Interface\DialogFrame\UI-DialogBox-Border]]
lib.MediaTable.border["Blizzard Dialog Gold"] = [[Interface\DialogFrame\UI-DialogBox-Gold-Border]]
lib.MediaTable.border["Blizzard Party"] = [[Interface\CHARACTERFRAME\UI-Party-Border]]
lib.MediaTable.border["Blizzard Tooltip"] = [[Interface\Tooltips\UI-Tooltip-Border]]
 
-- FONT
if not lib.MediaTable.font then lib.MediaTable.font = {} end
local SML_MT_font = lib.MediaTable.font
if locale == "koKR" then
LOCALE_MASK = lib.LOCALE_BIT_koKR
--
SML_MT_font["굵은 글꼴"] = [[Fonts\2002B.TTF]]
SML_MT_font["기본 글꼴"] = [[Fonts\2002.TTF]]
SML_MT_font["데미지 글꼴"] = [[Fonts\K_Damage.TTF]]
SML_MT_font["퀘스트 글꼴"] = [[Fonts\K_Pagetext.TTF]]
--
lib.DefaultMedia["font"] = "기본 글꼴" -- someone from koKR please adjust if needed
--
elseif locale == "zhCN" then
LOCALE_MASK = lib.LOCALE_BIT_zhCN
--
SML_MT_font["伤害数字"] = [[Fonts\ZYKai_C.ttf]]
SML_MT_font["默认"] = [[Fonts\ZYKai_T.ttf]]
SML_MT_font["聊天"] = [[Fonts\ZYHei.ttf]]
--
lib.DefaultMedia["font"] = "默认" -- someone from zhCN please adjust if needed
--
elseif locale == "zhTW" then
LOCALE_MASK = lib.LOCALE_BIT_zhTW
--
SML_MT_font["提示訊息"] = [[Fonts\bHEI00M.ttf]]
SML_MT_font["聊天"] = [[Fonts\bHEI01B.ttf]]
SML_MT_font["傷害數字"] = [[Fonts\bKAI00M.ttf]]
SML_MT_font["預設"] = [[Fonts\bLEI00D.ttf]]
--
lib.DefaultMedia["font"] = "預設" -- someone from zhTW please adjust if needed
 
elseif locale == "ruRU" then
LOCALE_MASK = lib.LOCALE_BIT_ruRU
--
SML_MT_font["Arial Narrow"] = [[Fonts\ARIALN.TTF]]
SML_MT_font["Friz Quadrata TT"] = [[Fonts\FRIZQT__.TTF]]
SML_MT_font["Morpheus"] = [[Fonts\MORPHEUS.TTF]]
SML_MT_font["Nimrod MT"] = [[Fonts\NIM_____.ttf]]
SML_MT_font["Skurri"] = [[Fonts\SKURRI.TTF]]
--
lib.DefaultMedia.font = "Friz Quadrata TT"
--
else
LOCALE_MASK = lib.LOCALE_BIT_western
locale_is_western = true
--
SML_MT_font["Arial Narrow"] = [[Fonts\ARIALN.TTF]]
SML_MT_font["Friz Quadrata TT"] = [[Fonts\FRIZQT__.TTF]]
SML_MT_font["Morpheus"] = [[Fonts\MORPHEUS.TTF]]
SML_MT_font["Skurri"] = [[Fonts\SKURRI.TTF]]
--
lib.DefaultMedia.font = "Friz Quadrata TT"
--
end
 
-- STATUSBAR
if not lib.MediaTable.statusbar then lib.MediaTable.statusbar = {} end
lib.MediaTable.statusbar["Blizzard"] = [[Interface\TargetingFrame\UI-StatusBar]]
lib.DefaultMedia.statusbar = "Blizzard"
 
-- SOUND
if not lib.MediaTable.sound then lib.MediaTable.sound = {} end
lib.MediaTable.sound["None"] = [[Interface\Quiet.mp3]] -- Relies on the fact that PlaySound[File] doesn't error on non-existing input.
lib.DefaultMedia.sound = "None"
 
local function rebuildMediaList(mediatype)
local mtable = mediaTable[mediatype]
if not mtable then return end
if not mediaList[mediatype] then mediaList[mediatype] = {} end
local mlist = mediaList[mediatype]
-- list can only get larger, so simply overwrite it
local i = 0
for k in pairs(mtable) do
i = i + 1
mlist[i] = k
end
table_sort(mlist)
end
 
function lib:Register(mediatype, key, data, langmask)
if type(mediatype) ~= "string" then
error(MAJOR..":Register(mediatype, key, data, langmask) - mediatype must be string, got "..type(mediatype))
end
if type(key) ~= "string" then
error(MAJOR..":Register(mediatype, key, data, langmask) - key must be string, got "..type(key))
end
if mediatype == lib.MediaType.FONT and ((langmask and band(langmask, LOCALE_MASK) == 0) or not (langmask or locale_is_western)) then return false end
mediatype = mediatype:lower()
if not mediaTable[mediatype] then mediaTable[mediatype] = {} end
local mtable = mediaTable[mediatype]
if mtable[key] then return false end
 
mtable[key] = data
rebuildMediaList(mediatype)
self.callbacks:Fire("LibSharedMedia_Registered", mediatype, key)
return true
end
 
function lib:Fetch(mediatype, key, noDefault)
local mtt = mediaTable[mediatype]
local overridekey = overrideMedia[mediatype]
local result = mtt and ((overridekey and mtt[overridekey] or mtt[key]) or (not noDefault and defaultMedia[mediatype] and mtt[defaultMedia[mediatype]])) or nil
 
return result
end
 
function lib:IsValid(mediatype, key)
return mediaTable[mediatype] and (not key or mediaTable[mediatype][key]) and true or false
end
 
function lib:HashTable(mediatype)
return mediaTable[mediatype]
end
 
function lib:List(mediatype)
if not mediaTable[mediatype] then
return nil
end
if not mediaList[mediatype] then
rebuildMediaList(mediatype)
end
return mediaList[mediatype]
end
 
function lib:GetGlobal(mediatype)
return overrideMedia[mediatype]
end
 
function lib:SetGlobal(mediatype, key)
if not mediaTable[mediatype] then
return false
end
overrideMedia[mediatype] = (key and mediaTable[mediatype][key]) and key or nil
self.callbacks:Fire("LibSharedMedia_SetGlobal", mediatype, overrideMedia[mediatype])
return true
end
 
function lib:GetDefault(mediatype)
return defaultMedia[mediatype]
end
 
function lib:SetDefault(mediatype, key)
if mediaTable[mediatype] and mediaTable[mediatype][key] and not defaultMedia[mediatype] then
defaultMedia[mediatype] = key
return true
else
return false
end
end
mNameplates/Libs/LibSharedMedia-3.0/lib.xml New file
0,0 → 1,4
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Script file="LibSharedMedia-3.0.lua" />
</Ui>
\ No newline at end of file
mNameplates/Libs/AceAddon-3.0/AceAddon-3.0.xml New file
0,0 → 1,4
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Script file="AceAddon-3.0.lua"/>
</Ui>
\ No newline at end of file
mNameplates/Libs/AceAddon-3.0/AceAddon-3.0.lua New file
0,0 → 1,642
--- **AceAddon-3.0** provides a template for creating addon objects.
-- It'll provide you with a set of callback functions that allow you to simplify the loading
-- process of your addon.\\
-- Callbacks provided are:\\
-- * **OnInitialize**, which is called directly after the addon is fully loaded.
-- * **OnEnable** which gets called during the PLAYER_LOGIN event, when most of the data provided by the game is already present.
-- * **OnDisable**, which is only called when your addon is manually being disabled.
-- @usage
-- -- A small (but complete) addon, that doesn't do anything,
-- -- but shows usage of the callbacks.
-- local MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon")
--
-- function MyAddon:OnInitialize()
-- -- do init tasks here, like loading the Saved Variables,
-- -- or setting up slash commands.
-- end
--
-- function MyAddon:OnEnable()
-- -- Do more initialization here, that really enables the use of your addon.
-- -- Register Events, Hook functions, Create Frames, Get information from
-- -- the game that wasn't available in OnInitialize
-- end
--
-- function MyAddon:OnDisable()
-- -- Unhook, Unregister Events, Hide frames that you created.
-- -- You would probably only use an OnDisable if you want to
-- -- build a "standby" mode, or be able to toggle modules on/off.
-- end
-- @class file
-- @name AceAddon-3.0.lua
-- @release $Id: AceAddon-3.0.lua 895 2009-12-06 16:28:55Z nevcairiel $
 
local MAJOR, MINOR = "AceAddon-3.0", 5
local AceAddon, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
 
if not AceAddon then return end -- No Upgrade needed.
 
AceAddon.frame = AceAddon.frame or CreateFrame("Frame", "AceAddon30Frame") -- Our very own frame
AceAddon.addons = AceAddon.addons or {} -- addons in general
AceAddon.statuses = AceAddon.statuses or {} -- statuses of addon.
AceAddon.initializequeue = AceAddon.initializequeue or {} -- addons that are new and not initialized
AceAddon.enablequeue = AceAddon.enablequeue or {} -- addons that are initialized and waiting to be enabled
AceAddon.embeds = AceAddon.embeds or setmetatable({}, {__index = function(tbl, key) tbl[key] = {} return tbl[key] end }) -- contains a list of libraries embedded in an addon
 
-- Lua APIs
local tinsert, tconcat, tremove = table.insert, table.concat, table.remove
local fmt, tostring = string.format, tostring
local select, pairs, next, type, unpack = select, pairs, next, type, unpack
local loadstring, assert, error = loadstring, assert, error
local setmetatable, getmetatable, rawset, rawget = setmetatable, getmetatable, rawset, rawget
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: LibStub, IsLoggedIn, geterrorhandler
 
--[[
xpcall safecall implementation
]]
local xpcall = xpcall
 
local function errorhandler(err)
return geterrorhandler()(err)
end
 
local function CreateDispatcher(argCount)
local code = [[
local xpcall, eh = ...
local method, ARGS
local function call() return method(ARGS) end
 
local function dispatch(func, ...)
method = func
if not method then return end
ARGS = ...
return xpcall(call, eh)
end
 
return dispatch
]]
 
local ARGS = {}
for i = 1, argCount do ARGS[i] = "arg"..i end
code = code:gsub("ARGS", tconcat(ARGS, ", "))
return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(xpcall, errorhandler)
end
 
local Dispatchers = setmetatable({}, {__index=function(self, argCount)
local dispatcher = CreateDispatcher(argCount)
rawset(self, argCount, dispatcher)
return dispatcher
end})
Dispatchers[0] = function(func)
return xpcall(func, errorhandler)
end
 
local function safecall(func, ...)
-- we check to see if the func is passed is actually a function here and don't error when it isn't
-- this safecall is used for optional functions like OnInitialize OnEnable etc. When they are not
-- present execution should continue without hinderance
if type(func) == "function" then
return Dispatchers[select('#', ...)](func, ...)
end
end
 
-- local functions that will be implemented further down
local Enable, Disable, EnableModule, DisableModule, Embed, NewModule, GetModule, GetName, SetDefaultModuleState, SetDefaultModuleLibraries, SetEnabledState, SetDefaultModulePrototype
 
-- used in the addon metatable
local function addontostring( self ) return self.name end
 
--- Create a new AceAddon-3.0 addon.
-- Any libraries you specified will be embeded, and the addon will be scheduled for
-- its OnInitialize and OnEnable callbacks.
-- The final addon object, with all libraries embeded, will be returned.
-- @paramsig [object ,]name[, lib, ...]
-- @param object Table to use as a base for the addon (optional)
-- @param name Name of the addon object to create
-- @param lib List of libraries to embed into the addon
-- @usage
-- -- Create a simple addon object
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon", "AceEvent-3.0")
--
-- -- Create a Addon object based on the table of a frame
-- local MyFrame = CreateFrame("Frame")
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon(MyFrame, "MyAddon", "AceEvent-3.0")
function AceAddon:NewAddon(objectorname, ...)
local object,name
local i=1
if type(objectorname)=="table" then
object=objectorname
name=...
i=2
else
name=objectorname
end
if type(name)~="string" then
error(("Usage: NewAddon([object,] name, [lib, lib, lib, ...]): 'name' - string expected got '%s'."):format(type(name)), 2)
end
if self.addons[name] then
error(("Usage: NewAddon([object,] name, [lib, lib, lib, ...]): 'name' - Addon '%s' already exists."):format(name), 2)
end
 
object = object or {}
object.name = name
 
local addonmeta = {}
local oldmeta = getmetatable(object)
if oldmeta then
for k, v in pairs(oldmeta) do addonmeta[k] = v end
end
addonmeta.__tostring = addontostring
 
setmetatable( object, addonmeta )
self.addons[name] = object
object.modules = {}
object.defaultModuleLibraries = {}
Embed( object ) -- embed NewModule, GetModule methods
self:EmbedLibraries(object, select(i,...))
 
-- add to queue of addons to be initialized upon ADDON_LOADED
tinsert(self.initializequeue, object)
return object
end
 
 
--- Get the addon object by its name from the internal AceAddon registry.
-- Throws an error if the addon object cannot be found (except if silent is set).
-- @param name unique name of the addon object
-- @param silent if true, the addon is optional, silently return nil if its not found
-- @usage
-- -- Get the Addon
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
function AceAddon:GetAddon(name, silent)
if not silent and not self.addons[name] then
error(("Usage: GetAddon(name): 'name' - Cannot find an AceAddon '%s'."):format(tostring(name)), 2)
end
return self.addons[name]
end
 
-- - Embed a list of libraries into the specified addon.
-- This function will try to embed all of the listed libraries into the addon
-- and error if a single one fails.
--
-- **Note:** This function is for internal use by :NewAddon/:NewModule
-- @paramsig addon, [lib, ...]
-- @param addon addon object to embed the libs in
-- @param lib List of libraries to embed into the addon
function AceAddon:EmbedLibraries(addon, ...)
for i=1,select("#", ... ) do
local libname = select(i, ...)
self:EmbedLibrary(addon, libname, false, 4)
end
end
 
-- - Embed a library into the addon object.
-- This function will check if the specified library is registered with LibStub
-- and if it has a :Embed function to call. It'll error if any of those conditions
-- fails.
--
-- **Note:** This function is for internal use by :EmbedLibraries
-- @paramsig addon, libname[, silent[, offset]]
-- @param addon addon object to embed the library in
-- @param libname name of the library to embed
-- @param silent marks an embed to fail silently if the library doesn't exist (optional)
-- @param offset will push the error messages back to said offset, defaults to 2 (optional)
function AceAddon:EmbedLibrary(addon, libname, silent, offset)
local lib = LibStub:GetLibrary(libname, true)
if not lib and not silent then
error(("Usage: EmbedLibrary(addon, libname, silent, offset): 'libname' - Cannot find a library instance of %q."):format(tostring(libname)), offset or 2)
elseif lib and type(lib.Embed) == "function" then
lib:Embed(addon)
tinsert(self.embeds[addon], libname)
return true
elseif lib then
error(("Usage: EmbedLibrary(addon, libname, silent, offset): 'libname' - Library '%s' is not Embed capable"):format(libname), offset or 2)
end
end
 
--- Return the specified module from an addon object.
-- Throws an error if the addon object cannot be found (except if silent is set)
-- @name //addon//:GetModule
-- @paramsig name[, silent]
-- @param name unique name of the module
-- @param silent if true, the module is optional, silently return nil if its not found (optional)
-- @usage
-- -- Get the Addon
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
-- -- Get the Module
-- MyModule = MyAddon:GetModule("MyModule")
function GetModule(self, name, silent)
if not self.modules[name] and not silent then
error(("Usage: GetModule(name, silent): 'name' - Cannot find module '%s'."):format(tostring(name)), 2)
end
return self.modules[name]
end
 
local function IsModuleTrue(self) return true end
 
--- Create a new module for the addon.
-- The new module can have its own embeded libraries and/or use a module prototype to be mixed into the module.\\
-- A module has the same functionality as a real addon, it can have modules of its own, and has the same API as
-- an addon object.
-- @name //addon//:NewModule
-- @paramsig name[, prototype|lib[, lib, ...]]
-- @param name unique name of the module
-- @param prototype object to derive this module from, methods and values from this table will be mixed into the module (optional)
-- @param lib List of libraries to embed into the addon
-- @usage
-- -- Create a module with some embeded libraries
-- MyModule = MyAddon:NewModule("MyModule", "AceEvent-3.0", "AceHook-3.0")
--
-- -- Create a module with a prototype
-- local prototype = { OnEnable = function(self) print("OnEnable called!") end }
-- MyModule = MyAddon:NewModule("MyModule", prototype, "AceEvent-3.0", "AceHook-3.0")
function NewModule(self, name, prototype, ...)
if type(name) ~= "string" then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'name' - string expected got '%s'."):format(type(name)), 2) end
if type(prototype) ~= "string" and type(prototype) ~= "table" and type(prototype) ~= "nil" then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'prototype' - table (prototype), string (lib) or nil expected got '%s'."):format(type(prototype)), 2) end
 
if self.modules[name] then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'name' - Module '%s' already exists."):format(name), 2) end
 
-- modules are basically addons. We treat them as such. They will be added to the initializequeue properly as well.
-- NewModule can only be called after the parent addon is present thus the modules will be initialized after their parent is.
local module = AceAddon:NewAddon(fmt("%s_%s", self.name or tostring(self), name))
 
module.IsModule = IsModuleTrue
module:SetEnabledState(self.defaultModuleState)
module.moduleName = name
 
if type(prototype) == "string" then
AceAddon:EmbedLibraries(module, prototype, ...)
else
AceAddon:EmbedLibraries(module, ...)
end
AceAddon:EmbedLibraries(module, unpack(self.defaultModuleLibraries))
 
if not prototype or type(prototype) == "string" then
prototype = self.defaultModulePrototype or nil
end
 
if type(prototype) == "table" then
local mt = getmetatable(module)
mt.__index = prototype
setmetatable(module, mt) -- More of a Base class type feel.
end
 
safecall(self.OnModuleCreated, self, module) -- Was in Ace2 and I think it could be a cool thing to have handy.
self.modules[name] = module
 
return module
end
 
--- Returns the real name of the addon or module, without any prefix.
-- @name //addon//:GetName
-- @paramsig
-- @usage
-- print(MyAddon:GetName())
-- -- prints "MyAddon"
function GetName(self)
return self.moduleName or self.name
end
 
--- Enables the Addon, if possible, return true or false depending on success.
-- This internally calls AceAddon:EnableAddon(), thus dispatching a OnEnable callback
-- and enabling all modules of the addon (unless explicitly disabled).\\
-- :Enable() also sets the internal `enableState` variable to true
-- @name //addon//:Enable
-- @paramsig
-- @usage
-- -- Enable MyModule
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
-- MyModule = MyAddon:GetModule("MyModule")
-- MyModule:Enable()
function Enable(self)
self:SetEnabledState(true)
return AceAddon:EnableAddon(self)
end
 
--- Disables the Addon, if possible, return true or false depending on success.
-- This internally calls AceAddon:DisableAddon(), thus dispatching a OnDisable callback
-- and disabling all modules of the addon.\\
-- :Disable() also sets the internal `enableState` variable to false
-- @name //addon//:Disable
-- @paramsig
-- @usage
-- -- Disable MyAddon
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
-- MyAddon:Disable()
function Disable(self)
self:SetEnabledState(false)
return AceAddon:DisableAddon(self)
end
 
--- Enables the Module, if possible, return true or false depending on success.
-- Short-hand function that retrieves the module via `:GetModule` and calls `:Enable` on the module object.
-- @name //addon//:EnableModule
-- @paramsig name
-- @usage
-- -- Enable MyModule using :GetModule
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
-- MyModule = MyAddon:GetModule("MyModule")
-- MyModule:Enable()
--
-- -- Enable MyModule using the short-hand
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
-- MyAddon:EnableModule("MyModule")
function EnableModule(self, name)
local module = self:GetModule( name )
return module:Enable()
end
 
--- Disables the Module, if possible, return true or false depending on success.
-- Short-hand function that retrieves the module via `:GetModule` and calls `:Disable` on the module object.
-- @name //addon//:DisableModule
-- @paramsig name
-- @usage
-- -- Disable MyModule using :GetModule
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
-- MyModule = MyAddon:GetModule("MyModule")
-- MyModule:Disable()
--
-- -- Disable MyModule using the short-hand
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
-- MyAddon:DisableModule("MyModule")
function DisableModule(self, name)
local module = self:GetModule( name )
return module:Disable()
end
 
--- Set the default libraries to be mixed into all modules created by this object.
-- Note that you can only change the default module libraries before any module is created.
-- @name //addon//:SetDefaultModuleLibraries
-- @paramsig lib[, lib, ...]
-- @param lib List of libraries to embed into the addon
-- @usage
-- -- Create the addon object
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon")
-- -- Configure default libraries for modules (all modules need AceEvent-3.0)
-- MyAddon:SetDefaultModuleLibraries("AceEvent-3.0")
-- -- Create a module
-- MyModule = MyAddon:NewModule("MyModule")
function SetDefaultModuleLibraries(self, ...)
if next(self.modules) then
error("Usage: SetDefaultModuleLibraries(...): cannot change the module defaults after a module has been registered.", 2)
end
self.defaultModuleLibraries = {...}
end
 
--- Set the default state in which new modules are being created.
-- Note that you can only change the default state before any module is created.
-- @name //addon//:SetDefaultModuleState
-- @paramsig state
-- @param state Default state for new modules, true for enabled, false for disabled
-- @usage
-- -- Create the addon object
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon")
-- -- Set the default state to "disabled"
-- MyAddon:SetDefaultModuleState(false)
-- -- Create a module and explicilty enable it
-- MyModule = MyAddon:NewModule("MyModule")
-- MyModule:Enable()
function SetDefaultModuleState(self, state)
if next(self.modules) then
error("Usage: SetDefaultModuleState(state): cannot change the module defaults after a module has been registered.", 2)
end
self.defaultModuleState = state
end
 
--- Set the default prototype to use for new modules on creation.
-- Note that you can only change the default prototype before any module is created.
-- @name //addon//:SetDefaultModulePrototype
-- @paramsig prototype
-- @param prototype Default prototype for the new modules (table)
-- @usage
-- -- Define a prototype
-- local prototype = { OnEnable = function(self) print("OnEnable called!") end }
-- -- Set the default prototype
-- MyAddon:SetDefaultModulePrototype(prototype)
-- -- Create a module and explicitly Enable it
-- MyModule = MyAddon:NewModule("MyModule")
-- MyModule:Enable()
-- -- should print "OnEnable called!" now
-- @see NewModule
function SetDefaultModulePrototype(self, prototype)
if next(self.modules) then
error("Usage: SetDefaultModulePrototype(prototype): cannot change the module defaults after a module has been registered.", 2)
end
if type(prototype) ~= "table" then
error(("Usage: SetDefaultModulePrototype(prototype): 'prototype' - table expected got '%s'."):format(type(prototype)), 2)
end
self.defaultModulePrototype = prototype
end
 
--- Set the state of an addon or module
-- This should only be called before any enabling actually happend, e.g. in/before OnInitialize.
-- @name //addon//:SetEnabledState
-- @paramsig state
-- @param state the state of an addon or module (enabled=true, disabled=false)
function SetEnabledState(self, state)
self.enabledState = state
end
 
 
--- Return an iterator of all modules associated to the addon.
-- @name //addon//:IterateModules
-- @paramsig
-- @usage
-- -- Enable all modules
-- for name, module in MyAddon:IterateModules() do
-- module:Enable()
-- end
local function IterateModules(self) return pairs(self.modules) end
 
-- Returns an iterator of all embeds in the addon
-- @name //addon//:IterateEmbeds
-- @paramsig
local function IterateEmbeds(self) return pairs(AceAddon.embeds[self]) end
 
--- Query the enabledState of an addon.
-- @name //addon//:IsEnabled
-- @paramsig
-- @usage
-- if MyAddon:IsEnabled() then
-- MyAddon:Disable()
-- end
local function IsEnabled(self) return self.enabledState end
local mixins = {
NewModule = NewModule,
GetModule = GetModule,
Enable = Enable,
Disable = Disable,
EnableModule = EnableModule,
DisableModule = DisableModule,
IsEnabled = IsEnabled,
SetDefaultModuleLibraries = SetDefaultModuleLibraries,
SetDefaultModuleState = SetDefaultModuleState,
SetDefaultModulePrototype = SetDefaultModulePrototype,
SetEnabledState = SetEnabledState,
IterateModules = IterateModules,
IterateEmbeds = IterateEmbeds,
GetName = GetName,
}
local function IsModule(self) return false end
local pmixins = {
defaultModuleState = true,
enabledState = true,
IsModule = IsModule,
}
-- Embed( target )
-- target (object) - target object to embed aceaddon in
--
-- this is a local function specifically since it's meant to be only called internally
function Embed(target)
for k, v in pairs(mixins) do
target[k] = v
end
for k, v in pairs(pmixins) do
target[k] = target[k] or v
end
end
 
 
-- - Initialize the addon after creation.
-- This function is only used internally during the ADDON_LOADED event
-- It will call the **OnInitialize** function on the addon object (if present),
-- and the **OnEmbedInitialize** function on all embeded libraries.
--
-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing.
-- @param addon addon object to intialize
function AceAddon:InitializeAddon(addon)
safecall(addon.OnInitialize, addon)
 
local embeds = self.embeds[addon]
for i = 1, #embeds do
local lib = LibStub:GetLibrary(embeds[i], true)
if lib then safecall(lib.OnEmbedInitialize, lib, addon) end
end
 
-- we don't call InitializeAddon on modules specifically, this is handled
-- from the event handler and only done _once_
end
 
-- - Enable the addon after creation.
-- Note: This function is only used internally during the PLAYER_LOGIN event, or during ADDON_LOADED,
-- if IsLoggedIn() already returns true at that point, e.g. for LoD Addons.
-- It will call the **OnEnable** function on the addon object (if present),
-- and the **OnEmbedEnable** function on all embeded libraries.\\
-- This function does not toggle the enable state of the addon itself, and will return early if the addon is disabled.
--
-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing.
-- Use :Enable on the addon itself instead.
-- @param addon addon object to enable
function AceAddon:EnableAddon(addon)
if type(addon) == "string" then addon = AceAddon:GetAddon(addon) end
if self.statuses[addon.name] or not addon.enabledState then return false end
 
-- set the statuses first, before calling the OnEnable. this allows for Disabling of the addon in OnEnable.
self.statuses[addon.name] = true
 
safecall(addon.OnEnable, addon)
 
-- make sure we're still enabled before continueing
if self.statuses[addon.name] then
local embeds = self.embeds[addon]
for i = 1, #embeds do
local lib = LibStub:GetLibrary(embeds[i], true)
if lib then safecall(lib.OnEmbedEnable, lib, addon) end
end
 
-- enable possible modules.
for name, module in pairs(addon.modules) do
self:EnableAddon(module)
end
end
return self.statuses[addon.name] -- return true if we're disabled
end
 
-- - Disable the addon
-- Note: This function is only used internally.
-- It will call the **OnDisable** function on the addon object (if present),
-- and the **OnEmbedDisable** function on all embeded libraries.\\
-- This function does not toggle the enable state of the addon itself, and will return early if the addon is still enabled.
--
-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing.
-- Use :Disable on the addon itself instead.
-- @param addon addon object to enable
function AceAddon:DisableAddon(addon)
if type(addon) == "string" then addon = AceAddon:GetAddon(addon) end
if not self.statuses[addon.name] then return false end
 
-- set statuses first before calling OnDisable, this allows for aborting the disable in OnDisable.
self.statuses[addon.name] = false
 
safecall( addon.OnDisable, addon )
 
-- make sure we're still disabling...
if not self.statuses[addon.name] then
local embeds = self.embeds[addon]
for i = 1, #embeds do
local lib = LibStub:GetLibrary(embeds[i], true)
if lib then safecall(lib.OnEmbedDisable, lib, addon) end
end
-- disable possible modules.
for name, module in pairs(addon.modules) do
self:DisableAddon(module)
end
end
 
return not self.statuses[addon.name] -- return true if we're disabled
end
 
--- Get an iterator over all registered addons.
-- @usage
-- -- Print a list of all installed AceAddon's
-- for name, addon in AceAddon:IterateAddons() do
-- print("Addon: " .. name)
-- end
function AceAddon:IterateAddons() return pairs(self.addons) end
 
--- Get an iterator over the internal status registry.
-- @usage
-- -- Print a list of all enabled addons
-- for name, status in AceAddon:IterateAddonStatus() do
-- if status then
-- print("EnabledAddon: " .. name)
-- end
-- end
function AceAddon:IterateAddonStatus() return pairs(self.statuses) end
 
-- Following Iterators are deprecated, and their addon specific versions should be used
-- e.g. addon:IterateEmbeds() instead of :IterateEmbedsOnAddon(addon)
function AceAddon:IterateEmbedsOnAddon(addon) return pairs(self.embeds[addon]) end
function AceAddon:IterateModulesOfAddon(addon) return pairs(addon.modules) end
 
-- Event Handling
local function onEvent(this, event, arg1)
if event == "ADDON_LOADED" or event == "PLAYER_LOGIN" then
-- if a addon loads another addon, recursion could happen here, so we need to validate the table on every iteration
while(#AceAddon.initializequeue > 0) do
local addon = tremove(AceAddon.initializequeue, 1)
-- this might be an issue with recursion - TODO: validate
if event == "ADDON_LOADED" then addon.baseName = arg1 end
AceAddon:InitializeAddon(addon)
tinsert(AceAddon.enablequeue, addon)
end
 
if IsLoggedIn() then
while(#AceAddon.enablequeue > 0) do
local addon = tremove(AceAddon.enablequeue, 1)
AceAddon:EnableAddon(addon)
end
end
end
end
 
AceAddon.frame:RegisterEvent("ADDON_LOADED")
AceAddon.frame:RegisterEvent("PLAYER_LOGIN")
AceAddon.frame:SetScript("OnEvent", onEvent)
 
-- upgrade embeded
for name, addon in pairs(AceAddon.addons) do
Embed(addon)
end
mNameplates/Libs/AceDB-3.0/AceDB-3.0.xml New file
0,0 → 1,4
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Script file="AceDB-3.0.lua"/>
</Ui>
\ No newline at end of file
mNameplates/Libs/AceDB-3.0/AceDB-3.0.lua New file
0,0 → 1,728
--- **AceDB-3.0** manages the SavedVariables of your addon.
-- It offers profile management, smart defaults and namespaces for modules.\\
-- Data can be saved in different data-types, depending on its intended usage.
-- The most common data-type is the `profile` type, which allows the user to choose
-- the active profile, and manage the profiles of all of his characters.\\
-- The following data types are available:
-- * **char** Character-specific data. Every character has its own database.
-- * **realm** Realm-specific data. All of the players characters on the same realm share this database.
-- * **class** Class-specific data. All of the players characters of the same class share this database.
-- * **race** Race-specific data. All of the players characters of the same race share this database.
-- * **faction** Faction-specific data. All of the players characters of the same faction share this database.
-- * **factionrealm** Faction and realm specific data. All of the players characters on the same realm and of the same faction share this database.
-- * **global** Global Data. All characters on the same account share this database.
-- * **profile** Profile-specific data. All characters using the same profile share this database. The user can control which profile should be used.
--
-- Creating a new Database using the `:New` function will return a new DBObject. A database will inherit all functions
-- of the DBObjectLib listed here. \\
-- If you create a new namespaced child-database (`:RegisterNamespace`), you'll get a DBObject as well, but note
-- that the child-databases cannot individually change their profile, and are linked to their parents profile - and because of that,
-- the profile related APIs are not available. Only `:RegisterDefaults` and `:ResetProfile` are available on child-databases.
--
-- For more details on how to use AceDB-3.0, see the [[AceDB-3.0 Tutorial]].
--
-- You may also be interested in [[libdualspec-1-0|LibDualSpec-1.0]] to do profile switching automatically when switching specs.
--
-- @usage
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("DBExample")
--
-- -- declare defaults to be used in the DB
-- local defaults = {
-- profile = {
-- setting = true,
-- }
-- }
--
-- function MyAddon:OnInitialize()
-- -- Assuming the .toc says ## SavedVariables: MyAddonDB
-- self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true)
-- end
-- @class file
-- @name AceDB-3.0.lua
-- @release $Id: AceDB-3.0.lua 940 2010-06-19 08:01:47Z nevcairiel $
local ACEDB_MAJOR, ACEDB_MINOR = "AceDB-3.0", 21
local AceDB, oldminor = LibStub:NewLibrary(ACEDB_MAJOR, ACEDB_MINOR)
 
if not AceDB then return end -- No upgrade needed
 
-- Lua APIs
local type, pairs, next, error = type, pairs, next, error
local setmetatable, getmetatable, rawset, rawget = setmetatable, getmetatable, rawset, rawget
 
-- WoW APIs
local _G = _G
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: LibStub
 
AceDB.db_registry = AceDB.db_registry or {}
AceDB.frame = AceDB.frame or CreateFrame("Frame")
 
local CallbackHandler
local CallbackDummy = { Fire = function() end }
 
local DBObjectLib = {}
 
--[[-------------------------------------------------------------------------
AceDB Utility Functions
---------------------------------------------------------------------------]]
 
-- Simple shallow copy for copying defaults
local function copyTable(src, dest)
if type(dest) ~= "table" then dest = {} end
if type(src) == "table" then
for k,v in pairs(src) do
if type(v) == "table" then
-- try to index the key first so that the metatable creates the defaults, if set, and use that table
v = copyTable(v, dest[k])
end
dest[k] = v
end
end
return dest
end
 
-- Called to add defaults to a section of the database
--
-- When a ["*"] default section is indexed with a new key, a table is returned
-- and set in the host table. These tables must be cleaned up by removeDefaults
-- in order to ensure we don't write empty default tables.
local function copyDefaults(dest, src)
-- this happens if some value in the SV overwrites our default value with a non-table
--if type(dest) ~= "table" then return end
for k, v in pairs(src) do
if k == "*" or k == "**" then
if type(v) == "table" then
-- This is a metatable used for table defaults
local mt = {
-- This handles the lookup and creation of new subtables
__index = function(t,k)
if k == nil then return nil end
local tbl = {}
copyDefaults(tbl, v)
rawset(t, k, tbl)
return tbl
end,
}
setmetatable(dest, mt)
-- handle already existing tables in the SV
for dk, dv in pairs(dest) do
if not rawget(src, dk) and type(dv) == "table" then
copyDefaults(dv, v)
end
end
else
-- Values are not tables, so this is just a simple return
local mt = {__index = function(t,k) return k~=nil and v or nil end}
setmetatable(dest, mt)
end
elseif type(v) == "table" then
if not rawget(dest, k) then rawset(dest, k, {}) end
if type(dest[k]) == "table" then
copyDefaults(dest[k], v)
if src['**'] then
copyDefaults(dest[k], src['**'])
end
end
else
if rawget(dest, k) == nil then
rawset(dest, k, v)
end
end
end
end
 
-- Called to remove all defaults in the default table from the database
local function removeDefaults(db, defaults, blocker)
-- remove all metatables from the db, so we don't accidentally create new sub-tables through them
setmetatable(db, nil)
-- loop through the defaults and remove their content
for k,v in pairs(defaults) do
if k == "*" or k == "**" then
if type(v) == "table" then
-- Loop through all the actual k,v pairs and remove
for key, value in pairs(db) do
if type(value) == "table" then
-- if the key was not explicitly specified in the defaults table, just strip everything from * and ** tables
if defaults[key] == nil and (not blocker or blocker[key] == nil) then
removeDefaults(value, v)
-- if the table is empty afterwards, remove it
if next(value) == nil then
db[key] = nil
end
-- if it was specified, only strip ** content, but block values which were set in the key table
elseif k == "**" then
removeDefaults(value, v, defaults[key])
end
end
end
elseif k == "*" then
-- check for non-table default
for key, value in pairs(db) do
if defaults[key] == nil and v == value then
db[key] = nil
end
end
end
elseif type(v) == "table" and type(db[k]) == "table" then
-- if a blocker was set, dive into it, to allow multi-level defaults
removeDefaults(db[k], v, blocker and blocker[k])
if next(db[k]) == nil then
db[k] = nil
end
else
-- check if the current value matches the default, and that its not blocked by another defaults table
if db[k] == defaults[k] and (not blocker or blocker[k] == nil) then
db[k] = nil
end
end
end
end
 
-- This is called when a table section is first accessed, to set up the defaults
local function initSection(db, section, svstore, key, defaults)
local sv = rawget(db, "sv")
 
local tableCreated
if not sv[svstore] then sv[svstore] = {} end
if not sv[svstore][key] then
sv[svstore][key] = {}
tableCreated = true
end
 
local tbl = sv[svstore][key]
 
if defaults then
copyDefaults(tbl, defaults)
end
rawset(db, section, tbl)
 
return tableCreated, tbl
end
 
-- Metatable to handle the dynamic creation of sections and copying of sections.
local dbmt = {
__index = function(t, section)
local keys = rawget(t, "keys")
local key = keys[section]
if key then
local defaultTbl = rawget(t, "defaults")
local defaults = defaultTbl and defaultTbl[section]
 
if section == "profile" then
local new = initSection(t, section, "profiles", key, defaults)
if new then
-- Callback: OnNewProfile, database, newProfileKey
t.callbacks:Fire("OnNewProfile", t, key)
end
elseif section == "profiles" then
local sv = rawget(t, "sv")
if not sv.profiles then sv.profiles = {} end
rawset(t, "profiles", sv.profiles)
elseif section == "global" then
local sv = rawget(t, "sv")
if not sv.global then sv.global = {} end
if defaults then
copyDefaults(sv.global, defaults)
end
rawset(t, section, sv.global)
else
initSection(t, section, section, key, defaults)
end
end
 
return rawget(t, section)
end
}
 
local function validateDefaults(defaults, keyTbl, offset)
if not defaults then return end
offset = offset or 0
for k in pairs(defaults) do
if not keyTbl[k] or k == "profiles" then
error(("Usage: AceDBObject:RegisterDefaults(defaults): '%s' is not a valid datatype."):format(k), 3 + offset)
end
end
end
 
local preserve_keys = {
["callbacks"] = true,
["RegisterCallback"] = true,
["UnregisterCallback"] = true,
["UnregisterAllCallbacks"] = true,
["children"] = true,
}
 
local realmKey = GetRealmName()
local charKey = UnitName("player") .. " - " .. realmKey
local _, classKey = UnitClass("player")
local _, raceKey = UnitRace("player")
local factionKey = UnitFactionGroup("player")
local factionrealmKey = factionKey .. " - " .. realmKey
-- Actual database initialization function
local function initdb(sv, defaults, defaultProfile, olddb, parent)
-- Generate the database keys for each section
 
-- map "true" to our "Default" profile
if defaultProfile == true then defaultProfile = "Default" end
 
local profileKey
if not parent then
-- Make a container for profile keys
if not sv.profileKeys then sv.profileKeys = {} end
 
-- Try to get the profile selected from the char db
profileKey = sv.profileKeys[charKey] or defaultProfile or charKey
 
-- save the selected profile for later
sv.profileKeys[charKey] = profileKey
else
-- Use the profile of the parents DB
profileKey = parent.keys.profile or defaultProfile or charKey
 
-- clear the profileKeys in the DB, namespaces don't need to store them
sv.profileKeys = nil
end
 
-- This table contains keys that enable the dynamic creation
-- of each section of the table. The 'global' and 'profiles'
-- have a key of true, since they are handled in a special case
local keyTbl= {
["char"] = charKey,
["realm"] = realmKey,
["class"] = classKey,
["race"] = raceKey,
["faction"] = factionKey,
["factionrealm"] = factionrealmKey,
["profile"] = profileKey,
["global"] = true,
["profiles"] = true,
}
 
validateDefaults(defaults, keyTbl, 1)
 
-- This allows us to use this function to reset an entire database
-- Clear out the old database
if olddb then
for k,v in pairs(olddb) do if not preserve_keys[k] then olddb[k] = nil end end
end
 
-- Give this database the metatable so it initializes dynamically
local db = setmetatable(olddb or {}, dbmt)
 
if not rawget(db, "callbacks") then
-- try to load CallbackHandler-1.0 if it loaded after our library
if not CallbackHandler then CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0", true) end
db.callbacks = CallbackHandler and CallbackHandler:New(db) or CallbackDummy
end
 
-- Copy methods locally into the database object, to avoid hitting
-- the metatable when calling methods
 
if not parent then
for name, func in pairs(DBObjectLib) do
db[name] = func
end
else
-- hack this one in
db.RegisterDefaults = DBObjectLib.RegisterDefaults
db.ResetProfile = DBObjectLib.ResetProfile
end
 
-- Set some properties in the database object
db.profiles = sv.profiles
db.keys = keyTbl
db.sv = sv
--db.sv_name = name
db.defaults = defaults
db.parent = parent
 
-- store the DB in the registry
AceDB.db_registry[db] = true
 
return db
end
 
-- handle PLAYER_LOGOUT
-- strip all defaults from all databases
-- and cleans up empty sections
local function logoutHandler(frame, event)
if event == "PLAYER_LOGOUT" then
for db in pairs(AceDB.db_registry) do
db.callbacks:Fire("OnDatabaseShutdown", db)
db:RegisterDefaults(nil)
 
-- cleanup sections that are empty without defaults
local sv = rawget(db, "sv")
for section in pairs(db.keys) do
if rawget(sv, section) then
-- global is special, all other sections have sub-entrys
-- also don't delete empty profiles on main dbs, only on namespaces
if section ~= "global" and (section ~= "profiles" or rawget(db, "parent")) then
for key in pairs(sv[section]) do
if not next(sv[section][key]) then
sv[section][key] = nil
end
end
end
if not next(sv[section]) then
sv[section] = nil
end
end
end
end
end
end
 
AceDB.frame:RegisterEvent("PLAYER_LOGOUT")
AceDB.frame:SetScript("OnEvent", logoutHandler)
 
 
--[[-------------------------------------------------------------------------
AceDB Object Method Definitions
---------------------------------------------------------------------------]]
 
--- Sets the defaults table for the given database object by clearing any
-- that are currently set, and then setting the new defaults.
-- @param defaults A table of defaults for this database
function DBObjectLib:RegisterDefaults(defaults)
if defaults and type(defaults) ~= "table" then
error("Usage: AceDBObject:RegisterDefaults(defaults): 'defaults' - table or nil expected.", 2)
end
 
validateDefaults(defaults, self.keys)
 
-- Remove any currently set defaults
if self.defaults then
for section,key in pairs(self.keys) do
if self.defaults[section] and rawget(self, section) then
removeDefaults(self[section], self.defaults[section])
end
end
end
 
-- Set the DBObject.defaults table
self.defaults = defaults
 
-- Copy in any defaults, only touching those sections already created
if defaults then
for section,key in pairs(self.keys) do
if defaults[section] and rawget(self, section) then
copyDefaults(self[section], defaults[section])
end
end
end
end
 
--- Changes the profile of the database and all of it's namespaces to the
-- supplied named profile
-- @param name The name of the profile to set as the current profile
function DBObjectLib:SetProfile(name)
if type(name) ~= "string" then
error("Usage: AceDBObject:SetProfile(name): 'name' - string expected.", 2)
end
 
-- changing to the same profile, dont do anything
if name == self.keys.profile then return end
 
local oldProfile = self.profile
local defaults = self.defaults and self.defaults.profile
 
-- Callback: OnProfileShutdown, database
self.callbacks:Fire("OnProfileShutdown", self)
 
if oldProfile and defaults then
-- Remove the defaults from the old profile
removeDefaults(oldProfile, defaults)
end
 
self.profile = nil
self.keys["profile"] = name
 
-- if the storage exists, save the new profile
-- this won't exist on namespaces.
if self.sv.profileKeys then
self.sv.profileKeys[charKey] = name
end
 
-- populate to child namespaces
if self.children then
for _, db in pairs(self.children) do
DBObjectLib.SetProfile(db, name)
end
end
 
-- Callback: OnProfileChanged, database, newProfileKey
self.callbacks:Fire("OnProfileChanged", self, name)
end
 
--- Returns a table with the names of the existing profiles in the database.
-- You can optionally supply a table to re-use for this purpose.
-- @param tbl A table to store the profile names in (optional)
function DBObjectLib:GetProfiles(tbl)
if tbl and type(tbl) ~= "table" then
error("Usage: AceDBObject:GetProfiles(tbl): 'tbl' - table or nil expected.", 2)
end
 
-- Clear the container table
if tbl then
for k,v in pairs(tbl) do tbl[k] = nil end
else
tbl = {}
end
 
local curProfile = self.keys.profile
 
local i = 0
for profileKey in pairs(self.profiles) do
i = i + 1
tbl[i] = profileKey
if curProfile and profileKey == curProfile then curProfile = nil end
end
 
-- Add the current profile, if it hasn't been created yet
if curProfile then
i = i + 1
tbl[i] = curProfile
end
 
return tbl, i
end
 
--- Returns the current profile name used by the database
function DBObjectLib:GetCurrentProfile()
return self.keys.profile
end
 
--- Deletes a named profile. This profile must not be the active profile.
-- @param name The name of the profile to be deleted
-- @param silent If true, do not raise an error when the profile does not exist
function DBObjectLib:DeleteProfile(name, silent)
if type(name) ~= "string" then
error("Usage: AceDBObject:DeleteProfile(name): 'name' - string expected.", 2)
end
 
if self.keys.profile == name then
error("Cannot delete the active profile in an AceDBObject.", 2)
end
 
if not rawget(self.profiles, name) and not silent then
error("Cannot delete profile '" .. name .. "'. It does not exist.", 2)
end
 
self.profiles[name] = nil
 
-- populate to child namespaces
if self.children then
for _, db in pairs(self.children) do
DBObjectLib.DeleteProfile(db, name, true)
end
end
 
-- Callback: OnProfileDeleted, database, profileKey
self.callbacks:Fire("OnProfileDeleted", self, name)
end
 
--- Copies a named profile into the current profile, overwriting any conflicting
-- settings.
-- @param name The name of the profile to be copied into the current profile
-- @param silent If true, do not raise an error when the profile does not exist
function DBObjectLib:CopyProfile(name, silent)
if type(name) ~= "string" then
error("Usage: AceDBObject:CopyProfile(name): 'name' - string expected.", 2)
end
 
if name == self.keys.profile then
error("Cannot have the same source and destination profiles.", 2)
end
 
if not rawget(self.profiles, name) and not silent then
error("Cannot copy profile '" .. name .. "'. It does not exist.", 2)
end
 
-- Reset the profile before copying
DBObjectLib.ResetProfile(self, nil, true)
 
local profile = self.profile
local source = self.profiles[name]
 
copyTable(source, profile)
 
-- populate to child namespaces
if self.children then
for _, db in pairs(self.children) do
DBObjectLib.CopyProfile(db, name, true)
end
end
 
-- Callback: OnProfileCopied, database, sourceProfileKey
self.callbacks:Fire("OnProfileCopied", self, name)
end
 
--- Resets the current profile to the default values (if specified).
-- @param noChildren if set to true, the reset will not be populated to the child namespaces of this DB object
-- @param noCallbacks if set to true, won't fire the OnProfileReset callback
function DBObjectLib:ResetProfile(noChildren, noCallbacks)
local profile = self.profile
 
for k,v in pairs(profile) do
profile[k] = nil
end
 
local defaults = self.defaults and self.defaults.profile
if defaults then
copyDefaults(profile, defaults)
end
 
-- populate to child namespaces
if self.children and not noChildren then
for _, db in pairs(self.children) do
DBObjectLib.ResetProfile(db, nil, noCallbacks)
end
end
 
-- Callback: OnProfileReset, database
if not noCallbacks then
self.callbacks:Fire("OnProfileReset", self)
end
end
 
--- Resets the entire database, using the string defaultProfile as the new default
-- profile.
-- @param defaultProfile The profile name to use as the default
function DBObjectLib:ResetDB(defaultProfile)
if defaultProfile and type(defaultProfile) ~= "string" then
error("Usage: AceDBObject:ResetDB(defaultProfile): 'defaultProfile' - string or nil expected.", 2)
end
 
local sv = self.sv
for k,v in pairs(sv) do
sv[k] = nil
end
 
local parent = self.parent
 
initdb(sv, self.defaults, defaultProfile, self)
 
-- fix the child namespaces
if self.children then
if not sv.namespaces then sv.namespaces = {} end
for name, db in pairs(self.children) do
if not sv.namespaces[name] then sv.namespaces[name] = {} end
initdb(sv.namespaces[name], db.defaults, self.keys.profile, db, self)
end
end
 
-- Callback: OnDatabaseReset, database
self.callbacks:Fire("OnDatabaseReset", self)
-- Callback: OnProfileChanged, database, profileKey
self.callbacks:Fire("OnProfileChanged", self, self.keys["profile"])
 
return self
end
 
--- Creates a new database namespace, directly tied to the database. This
-- is a full scale database in it's own rights other than the fact that
-- it cannot control its profile individually
-- @param name The name of the new namespace
-- @param defaults A table of values to use as defaults
function DBObjectLib:RegisterNamespace(name, defaults)
if type(name) ~= "string" then
error("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - string expected.", 2)
end
if defaults and type(defaults) ~= "table" then
error("Usage: AceDBObject:RegisterNamespace(name, defaults): 'defaults' - table or nil expected.", 2)
end
if self.children and self.children[name] then
error ("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - a namespace with that name already exists.", 2)
end
 
local sv = self.sv
if not sv.namespaces then sv.namespaces = {} end
if not sv.namespaces[name] then
sv.namespaces[name] = {}
end
 
local newDB = initdb(sv.namespaces[name], defaults, self.keys.profile, nil, self)
 
if not self.children then self.children = {} end
self.children[name] = newDB
return newDB
end
 
--- Returns an already existing namespace from the database object.
-- @param name The name of the new namespace
-- @param silent if true, the addon is optional, silently return nil if its not found
-- @usage
-- local namespace = self.db:GetNamespace('namespace')
-- @return the namespace object if found
function DBObjectLib:GetNamespace(name, silent)
if type(name) ~= "string" then
error("Usage: AceDBObject:GetNamespace(name): 'name' - string expected.", 2)
end
if not silent and not (self.children and self.children[name]) then
error ("Usage: AceDBObject:GetNamespace(name): 'name' - namespace does not exist.", 2)
end
if not self.children then self.children = {} end
return self.children[name]
end
 
--[[-------------------------------------------------------------------------
AceDB Exposed Methods
---------------------------------------------------------------------------]]
 
--- Creates a new database object that can be used to handle database settings and profiles.
-- By default, an empty DB is created, using a character specific profile.
--
-- You can override the default profile used by passing any profile name as the third argument,
-- or by passing //true// as the third argument to use a globally shared profile called "Default".
--
-- Note that there is no token replacement in the default profile name, passing a defaultProfile as "char"
-- will use a profile named "char", and not a character-specific profile.
-- @param tbl The name of variable, or table to use for the database
-- @param defaults A table of database defaults
-- @param defaultProfile The name of the default profile. If not set, a character specific profile will be used as the default.
-- You can also pass //true// to use a shared global profile called "Default".
-- @usage
-- -- Create an empty DB using a character-specific default profile.
-- self.db = LibStub("AceDB-3.0"):New("MyAddonDB")
-- @usage
-- -- Create a DB using defaults and using a shared default profile
-- self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true)
function AceDB:New(tbl, defaults, defaultProfile)
if type(tbl) == "string" then
local name = tbl
tbl = _G[name]
if not tbl then
tbl = {}
_G[name] = tbl
end
end
 
if type(tbl) ~= "table" then
error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'tbl' - table expected.", 2)
end
 
if defaults and type(defaults) ~= "table" then
error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaults' - table expected.", 2)
end
 
if defaultProfile and type(defaultProfile) ~= "string" and defaultProfile ~= true then
error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaultProfile' - string or true expected.", 2)
end
 
return initdb(tbl, defaults, defaultProfile)
end
 
-- upgrade existing databases
for db in pairs(AceDB.db_registry) do
if not db.parent then
for name,func in pairs(DBObjectLib) do
db[name] = func
end
else
db.RegisterDefaults = DBObjectLib.RegisterDefaults
db.ResetProfile = DBObjectLib.ResetProfile
end
end
mNameplates/Libs/LibGUIFactory-1.0/LibGUIFactory-1.0.toc New file
0,0 → 1,11
## Interface: 40000
## Title: Lib: GUIFactory-1.0
## Author: mangeg
## OptionalDeps: LibStub, Ace3, LibSharedMedia-3.0
## X-Category: Library
## X-Curse-Packaged-Version: r30
## X-Curse-Project-Name: LibGUIFactory-1.0
## X-Curse-Project-ID: gui-factory-1-0
## X-Curse-Repository-ID: wow/gui-factory-1-0/mainline
 
lib.xml
\ No newline at end of file
mNameplates/Libs/LibGUIFactory-1.0/lib.xml New file
0,0 → 1,19
<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="LibGUIFactory-1.0.lua"/>
 
<Script file="Widgets\UIF-Button.lua"/>
<Script file="Widgets\UIF-CheckBox.lua"/>
<Script file="Widgets\UIF-ColorSelect.lua"/>
<Script file="Widgets\UIF-DropDown.lua"/>
<Script file="Widgets\UIF-DropDownGroup.lua"/>
<Script file="Widgets\UIF-DropDownItems.lua"/>
<Script file="Widgets\UIF-Frame.lua"/>
<Script file="Widgets\UIF-InlineGroup.lua"/>
<Script file="Widgets\UIF-Slider.lua"/>
<Script file="Widgets\UIF-TabGroup.lua"/>
<Script file="Widgets\UIF-TreeGroup.lua"/>
<Script file="Widgets\UIF-NewLine.lua"/>
<Script file="Widgets\UIF-Label.lua"/>
</Ui>
 
mNameplates/Libs/LibGUIFactory-1.0/Widgets/UIF-CheckBox.lua New file
0,0 → 1,52
local AceGUI = LibStub("AceGUI-3.0")
 
 
--------------------------
-- Check Box --
--------------------------
--[[
Events :
OnValueChanged
 
]]
do
local Type = "UIF-CheckBox"
local Version = 4
 
local function SetFont(self, font, size, flags)
self.text:SetFont(font, size, flags)
end
 
local function SetFontColor(self, color)
self.newColor = color
self.text:SetTextColor(unpack(color))
end
 
local function SetDisabled(self, disabled)
self.oldSetDisable(self, disabled)
if not disabled and self.newColor then
self.text:SetTextColor(unpack(self.newColor))
end
end
 
local function SetValue(self, value)
self.oldSetValue(self, value)
SetDisabled(self, self.disabled)
end
 
local function Constructor()
local self = AceGUI:Create("CheckBox")
self.type = Type
 
self.oldSetDisable = self.SetDisabled
self.oldSetValue = self.SetValue
self.SetDisabled = SetDisabled
self.SetValue = SetValue
 
self.SetFont = SetFont
self.SetFontColor = SetFontColor
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
mNameplates/Libs/LibGUIFactory-1.0/Widgets/UIF-DropDownGroup.lua New file
0,0 → 1,221
local AceGUI = LibStub("AceGUI-3.0")
 
-- Lua APIs
local assert, pairs, type = assert, pairs, type
 
-- WoW APIs
local CreateFrame = CreateFrame
 
--[[
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 = "UIF-DropdownGroup"
local Version = 13
 
local function OnAcquire(self)
self.dropdown:SetText("")
self:SetDropdownWidth(200)
self:SetTitle("")
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
 
self.titletext:SetFontObject("GameFontNormal")
self.border:SetBackdropBorderColor(0.4,0.4,0.4)
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 SetBorderColor(self, color)
self.border:SetBackdropBorderColor(unpack(color))
end
 
local function SetFont(self, font, size, flags)
if not self.fontO then
self.fontO = CreateFont("UIFDropdownFont")
self.fontO:SetFont(font, size, flags)
end
self.titletext:SetFontObject(self.fontO)
end
 
local function SetFontColor(self, color)
local font, size, flags = GameFontNormal:GetFont()
if not self.fontO then
self.fontO = CreateFont("UIFDropdownFont")
self.fontO:SetFont(font, size, flags)
self.fontO:SetTextColor(unpack(color))
end
self.titletext:SetFontObject(self.fontO)
end
 
local function SetTitle(self,title)
self.titletext:SetText(title)
self.dropdown.frame:ClearAllPoints()
if title and title ~= "" then
self.dropdown.frame:SetPoint("TOPRIGHT", self.frame, "TOPRIGHT", -2, 0)
else
self.dropdown.frame:SetPoint("TOPLEFT", self.frame, "TOPLEFT", -1, 0)
end
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 SetDropdownWidget(self, dropdown)
self.dropdown:Release()
self.dropdown = dropdown
dropdown.frame:SetParent(self.frame)
dropdown.frame:SetFrameLevel(dropdown.frame:GetFrameLevel() + 2)
dropdown.parentgroup = self
dropdown:SetCallback("OnValueChanged",SelectedGroup)
dropdown.frame:SetPoint("TOPLEFT",self.frame,"TOPLEFT", -1, 0)
dropdown.frame:Show()
dropdown:SetLabel("")
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.SetFont = SetFont
self.SetFontColor = SetFontColor
self.SetBorderColor = SetBorderColor
 
self.SetDropdownWidget = SetDropdownWidget
 
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, -5)
titletext:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -4, -5)
titletext:SetJustifyH("LEFT")
titletext:SetHeight(18)
self.titletext = titletext
 
local dropdown = AceGUI:Create("Dropdown")
self.dropdown = dropdown
dropdown.frame:SetParent(frame)
dropdown.frame:SetFrameLevel(dropdown.frame:GetFrameLevel() + 2)
dropdown.parentgroup = self
dropdown:SetCallback("OnValueChanged",SelectedGroup)
dropdown.frame:SetPoint("TOPLEFT",frame,"TOPLEFT", -1, 0)
dropdown.frame:Show()
dropdown:SetLabel("")
 
local border = CreateFrame("Frame",nil,frame)
self.border = border
border:SetPoint("TOPLEFT",frame,"TOPLEFT",0,-26)
border:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,3)
 
border:SetBackdrop(PaneBackdrop)
border:SetBackdropColor(0.1,0.1,0.1,0.5)
border:SetBackdropBorderColor(0.4,0.4,0.4)
 
--Container Support
local content = CreateFrame("Frame",nil,border)
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
mNameplates/Libs/LibGUIFactory-1.0/Widgets/UIF-Frame.lua New file
0,0 → 1,332
local AceGUI = LibStub("AceGUI-3.0")
 
-- Lua APIs
local pairs, assert, type = pairs, assert, type
 
-- WoW APIs
local CreateFrame, UIParent = CreateFrame, UIParent
 
----------------
-- Main Frame --
----------------
--[[
Events :
OnClose
 
]]
do
local Type = "UIF-Frame"
local Version = 11
 
local FrameBackdrop = {
bgFile="Interface\\ChatFrame\\ChatFrameBackground",
edgeFile="Interface\\Tooltips\\UI-Tooltip-Border",
tile = true, tileSize = 32, edgeSize = 16,
insets = { left = 3, right = 3, top = 3, bottom = 3 }
}
 
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 SetTitle(self,title)
self.titletext:SetText(title)
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
 
if self.oldButton then
self.closebutton:Release()
 
self.closebutton = self.oldButton
self.oldButton = nil
end
self.titletext:SetFontObject("GameFontNormal")
self.frame:SetBackdropColor(0,0,0,0.5)
self.frame:SetBackdropBorderColor(1,1,1,1)
self.title:SetBackdropColor(0,0,0,1)
self.title:SetBackdropBorderColor(1, 1, 1, 1)
self.statustext:SetText()
end
 
local function SetTitleFont(self, font, size, flags)
self.fontO = self.fontO or UIFFrameFont or CreateFont("UIFFrameFont")
self.fontO:SetFont(font, size, flags)
self.titletext:SetFontObject("UIFFrameFont")
end
 
local function SetTitleFontColor(self, color)
local font, size, flags = GameFontNormal:GetFont()
if not self.fontO then
self.fontO = UIFFrameFont or CreateFont("UIFFrameFont")
self.fontO:SetFont(font, size, flags)
end
self.fontO:SetTextColor(unpack(color))
end
 
local function SetBorderColor(self, color)
self.frame:SetBackdropBorderColor(unpack(color))
self.title:SetBackdropBorderColor(unpack(color))
end
 
local function SetBackColor(self, color)
local r, g, b = unpack(color)
self.frame:SetBackdropColor(unpack(color))
self.title:SetBackdropColor(r, g, b, 1)
end
 
local function SetButton(self, closebutton)
self.oldButton = self.closebutton
self.oldButton:Hide()
 
self.closebutton = closebutton
closebutton.frame:SetParent(self.frame)
closebutton:SetCallback("OnClick", closeOnClick)
closebutton.frame:ClearAllPoints()
closebutton.frame:SetPoint("BOTTOMRIGHT", -27, 17)
closebutton.frame:SetHeight(20)
closebutton.frame:SetWidth(100)
closebutton.frame:SetText(CLOSE)
 
--closebutton.frame:SetFrameLevel(c)
--closebutton.frame:SetFrameStrata("TOOLTIP")
 
closebutton.obj = self
 
closebutton.frame:Show()
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 = Type
 
self.Hide = Hide
self.Show = Show
self.SetTitle = SetTitle
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
self.SetStatusTable = SetStatusTable
self.ApplyStatus = ApplyStatus
self.OnWidthSet = OnWidthSet
self.OnHeightSet = OnHeightSet
 
self.SetButton = SetButton
self.SetTitleFont = SetTitleFont
self.SetTitleFontColor = SetTitleFontColor
self.SetBorderColor = SetBorderColor
self.SetBackColor = SetBackColor
 
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,0.5)
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 title = CreateFrame("Frame",nil,frame)
local titletext = title:CreateFontString(nil,"OVERLAY","GameFontNormal")
titletext:SetPoint("CENTER",frame,"TOP")
 
 
self.title = title
title:EnableMouse()
title:SetScript("OnMouseDown",titleOnMouseDown)
title:SetScript("OnMouseUp", frameOnMouseUp)
title:SetBackdrop(PaneBackdrop)
title:SetPoint("TOPLEFT",titletext,"TOPLEFT", -10, 5)
title:SetPoint("BOTTOMRIGHT",titletext,"BOTTOMRIGHT", 10, -10)
title:SetBackdropColor(0,0,0,1)
title:SetBackdropBorderColor(1,1,1,1)
 
self.titletext = titletext
 
local statustext = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
statustext:SetPoint("LEFT", frame, "BOTTOMLEFT", 17, 20)
self.statustext = statustext
 
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", frameOnMouseUp)
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", frameOnMouseUp)
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", frameOnMouseUp)
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
mNameplates/Libs/LibGUIFactory-1.0/Widgets/UIF-Button.lua New file
0,0 → 1,33
local AceGUI = LibStub("AceGUI-3.0")
 
-- WoW APIs
local _G = _G
local CreateFrame, UIParent = CreateFrame, UIParent
 
--------------------------
-- Button --
--------------------------
do
local Type = "UIF-Button"
local Version = 3
 
local function SetFont(self, font, fontSize, flags)
self.text:SetFont(font, fontSize, flags)
end
 
local function SetFontColor(self, color)
self.text:SetTextColor(unpack(color))
end
 
local function Constructor()
local self = AceGUI:Create("Button")
self.type = Type
 
self.SetFont = SetFont
self.SetFontColor = SetFontColor
 
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
mNameplates/Libs/LibGUIFactory-1.0/Widgets/UIF-InlineGroup.lua New file
0,0 → 1,125
local Type, Version = "UIF-InlineGroup", 4
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI.GetWidgetVersion and AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
-- Lua APIs
local pairs = pairs
 
-- WoW APIs
local CreateFrame, UIParent = CreateFrame, UIParent
 
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetWidth(300)
self:SetHeight(100)
end,
 
-- ["OnRelease"] = nil,
 
["SetTitle"] = function(self,title)
self.titletext:SetText(title)
end,
 
 
["LayoutFinished"] = function(self, width, height)
if self.noAutoHeight then return end
self:SetHeight((height or 0) + 40)
end,
 
["OnWidthSet"] = function(self, width)
local content = self.content
local contentwidth = width - 20
if contentwidth < 0 then
contentwidth = 0
end
content:SetWidth(contentwidth)
content.width = contentwidth
end,
 
["OnHeightSet"] = function(self, height)
local content = self.content
local contentheight = height - 20
if contentheight < 0 then
contentheight = 0
end
content:SetHeight(contentheight)
content.height = contentheight
end,
 
["SetFont"] = function(self, font, size, flags)
self.titletext:SetFont(font, size, flags)
end,
 
["SetFontColor"] = function(self, color)
self.titletext:SetTextColor(unpack(color))
end,
 
["SetBGTexture"] = function(self, texture)
PaneBackdrop.bgFile = texture
self.border:SetBackdrop(PaneBackdrop)
end,
 
["SetBorderTexture"] = function(self, texture)
PaneBackdrop.edgeFile = texture
self.border:SetBackdrop(PaneBackdrop)
end,
 
["SetBGColor"] = function(self, color)
self.border:SetBackdropColor(unpack(color))
end,
 
["SetBorderColor"] = function(self, color)
self.border:SetBackdropBorderColor(unpack(color))
end,
}
 
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local PaneBackdrop = {
bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
tile = true, tileSize = 16, edgeSize = 16,
insets = { left = 3, right = 3, top = 5, bottom = 3 }
}
 
local function Constructor()
local frame = CreateFrame("Frame", nil, UIParent)
frame:SetFrameStrata("FULLSCREEN_DIALOG")
 
local titletext = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
titletext:SetPoint("TOPLEFT", 14, 0)
titletext:SetPoint("TOPRIGHT", -14, 0)
titletext:SetJustifyH("LEFT")
titletext:SetHeight(18)
 
local border = CreateFrame("Frame", nil, frame)
border:SetPoint("TOPLEFT", 0, -17)
border:SetPoint("BOTTOMRIGHT", -1, 3)
border:SetBackdrop(PaneBackdrop)
border:SetBackdropColor(0.1, 0.1, 0.1, 0.5)
border:SetBackdropBorderColor(0.4, 0.4, 0.4)
 
--Container Support
local content = CreateFrame("Frame", nil, border)
content:SetPoint("TOPLEFT", 10, -10)
content:SetPoint("BOTTOMRIGHT", -10, 10)
 
local widget = {
frame = frame,
content = content,
titletext = titletext,
border = border,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
 
return AceGUI:RegisterAsContainer(widget)
end
 
AceGUI:RegisterWidgetType(Type, Constructor, Version)
\ No newline at end of file
mNameplates/Libs/LibGUIFactory-1.0/Widgets/UIF-DropDown.lua New file
0,0 → 1,298
local AceGUI = LibStub("AceGUI-3.0")
 
local function fixlevels(parent,...)
local i = 1
local child = select(i, ...)
while child do
child:SetFrameLevel(parent:GetFrameLevel()+1)
fixlevels(child, child:GetChildren())
i = i + 1
child = select(i, ...)
end
end
 
local function fixstrata(strata, parent, ...)
local i = 1
local child = select(i, ...)
parent:SetFrameStrata(strata)
while child do
fixstrata(strata, child, child:GetChildren())
i = i + 1
child = select(i, ...)
end
end
 
 
do
local widgetType = "UIFDropdown-Pullout"
local widgetVersion = 107
 
-- exported
local function AddItem(self, item)
self.items[#self.items + 1] = item
 
local h = 0
for i, item in pairs(self.items) do
h = h + item.frame:GetHeight()
end
self.itemFrame:SetHeight(h)
self.frame:SetHeight(min(h + 34, self.maxHeight)) -- +34: 20 for scrollFrame placement (10 offset) and +14 for item placement
 
item.frame:SetPoint("LEFT", self.itemFrame, "LEFT")
item.frame:SetPoint("RIGHT", self.itemFrame, "RIGHT")
 
item:SetPullout(self)
item:SetOnEnter(OnEnter)
end
 
-- exported
local function Open(self, point, relFrame, relPoint, x, y)
local items = self.items
local frame = self.frame
local itemFrame = self.itemFrame
 
frame:SetPoint(point, relFrame, relPoint, x, y)
 
 
local height = 8
for i, item in pairs(items) do
if i == 1 then
item:SetPoint("TOP", itemFrame, "TOP", 0, -2)
else
item:SetPoint("TOP", items[i-1].frame, "BOTTOM", 0, 1)
end
 
item:Show()
height = height + item.frame:GetHeight()
end
itemFrame:SetHeight(height)
fixstrata("TOOLTIP", frame, frame:GetChildren())
frame:Show()
self:Fire("OnOpen")
end
 
-- exported
local function SetMaxHeight(self, height)
self.maxHeight = height or defaultMaxHeight
if self.frame:GetHeight() > height then
self.frame:SetHeight(height)
elseif (self.itemFrame:GetHeight() + 34) < height then
self.frame:SetHeight(self.itemFrame:GetHeight() + 34) -- see :AddItem
end
end
 
--[[ Constructor ]]--
 
local function Constructor()
local self = AceGUI:Create("Dropdown-Pullout")
self.type = widgetType
 
self.AddItem = AddItem
self.Open = Open
self.SetMaxHeight = SetMaxHeight
 
AceGUI:RegisterAsWidget(self)
return self
end
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion)
end
 
do
local widgetType = "UIF-Dropdown"
local widgetVersion = 22
 
local function OnPulloutOpen(this)
local self = this.userdata.obj
local value = self.value
 
if not self.multiselect then
for i, item in this:IterateItems() do
item:SetValue(item.userdata.value == value)
end
end
 
self.open = true
end
 
local function OnPulloutClose(this)
local self = this.userdata.obj
self.open = nil
self:Fire("OnClosed")
end
 
local function OnAcquire(self)
local pullout = AceGUI:Create("UIFDropdown-Pullout")
self.pullout = pullout
pullout.userdata.obj = self
pullout:SetCallback("OnClose", OnPulloutClose)
pullout:SetCallback("OnOpen", OnPulloutOpen)
self.pullout.frame:SetFrameLevel(self.frame:GetFrameLevel() + 1)
fixlevels(self.pullout.frame, self.pullout.frame:GetChildren())
self:SetHeight(44)
self:SetWidth(200)
end
 
local function ShowMultiText(self)
local text
for i, widget in self.pullout:IterateItems() do
if widget.type == "Dropdown-Item-Toggle" or widget.type == "UIFDropdown-Item-Toggle" then
if widget:GetValue() then
if text then
text = text..", "..widget:GetText()
else
text = widget:GetText()
end
end
end
end
self:SetText(text)
end
 
local function SetFont(self, font, size, flags)
self.text:SetFont(font, size, flags)
end
 
local function SetFontColor(self, color)
self.text:SetTextColor(unpack(color))
end
 
local function SetItemFont(self, font, size, flags)
self.ItemFont = self.ItemFont or UIFDropdownItemFont or CreateFont("UIFDropdownItemFont")
self.ItemFont:SetFont(font, size, flags)
self.UseCustonItemFont = true
end
 
local function SetItemFontColor(self, color)
local font, size, flags = GameFontNormalSmall:GetFont()
if not self.ItemFont then
self.ItemFont = self.ItemFont or UIFDropdownItemFont or CreateFont("UIFDropdownItemFont")
self.ItemFont:SetFont(font, size, flags)
end
self.ItemFont:SetTextColor(unpack(color))
self.UseCustonItemFont = true
end
 
local function OnItemValueChanged(this, event, checked)
local self = this.userdata.obj
 
if self.multiselect then
self:Fire("OnValueChanged", this.userdata.value, checked)
ShowMultiText(self)
else
if checked then
self:SetValue(this.userdata.value)
self:Fire("OnValueChanged", this.userdata.value)
else
this:SetValue(true)
end
if self.open then
self.pullout:Close()
end
end
end
 
local function SetValue(self, value)
if self.list then
if type(self.list[value]) == "table" then
self:SetText(self.list[value].text or "")
else
self:SetText(self.list[value] or "")
end
end
self.value = value
end
 
local function AddListItem(self, value, text, icon, disabled)
local item = AceGUI:Create("UIFDropdown-Item-Toggle")
if self.UseCustonItemFont then
item:SetFont("UIFDropdownItemFont")
end
if disabled then
item:SetDisabled(disabled)
end
item:SetIcon(icon)
item:SetText(text)
item.userdata.obj = self
item.userdata.value = value
item:SetCallback("OnValueChanged", OnItemValueChanged)
self.pullout:AddItem(item)
end
 
local function AddCloseButton(self)
if not self.hasClose then
local close = AceGUI:Create("Dropdown-Item-Execute")
close:SetText(CLOSE)
self.pullout:AddItem(close)
self.hasClose = true
end
end
 
local sortlist = {}
local function SetList(self, list)
self.list = list
self.pullout:Clear()
self.hasClose = nil
if not list then return end
 
for v in pairs(list) do
sortlist[#sortlist + 1] = v
end
table.sort(sortlist)
 
for i, value in pairs(sortlist) do
if type(list[value]) == "table" then
AddListItem(self, list[value].value, list[value].text, list[value].icon, list[value].disabled)
else
AddListItem(self, value, list[value])
end
sortlist[i] = nil
end
if self.multiselect then
ShowMultiText(self)
AddCloseButton(self)
end
end
 
local function SetMultiselect(self, multi)
self.multiselect = multi
if multi then
ShowMultiText(self)
AddCloseButton(self)
end
end
 
local function SetItemValue(self, item, value)
if not self.multiselect then return end
for i, widget in self.pullout:IterateItems() do
if widget.userdata.value == item then
if widget.SetValue then
widget:SetValue(value)
end
end
end
ShowMultiText(self)
end
 
local function Constructor()
local self = AceGUI:Create("Dropdown")
self.type = widgetType
 
self.OnAcquire = OnAcquire
 
self.SetItemFont = SetItemFont
self.SetFont = SetFont
self.SetFontColor = SetFontColor
self.SetItemFontColor = SetItemFontColor
 
self.SetList = SetList
self.AddListItem = AddListItem
self.SetValue = SetValue
self.SetMultiselect = SetMultiselect
self.SetItemValue = SetItemValue
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion)
end
mNameplates/Libs/LibGUIFactory-1.0/Widgets/UIF-TreeGroup.lua New file
0,0 → 1,414
local AceGUI = LibStub("AceGUI-3.0")
 
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
 
do
local Type = "UIF-TreeGroup"
local Version = 32
 
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
 
self.tree = nil
end
 
local function BuildUniqueValue(...)
local n = select('#', ...)
if n == 1 then
return ...
else
return (...).."\001"..BuildUniqueValue(select(2,...))
end
end
 
local function GetTableData(t, key, entry)
for i, v in pairs(t) do
if v[key] == entry then return v end
end
end
 
local function FindInTree(tree, ...)
local n = select("#", ...)
for i, data in pairs(tree) do
local t = ...
if data.value == t and n == 1 then
return data
elseif data.value == t then
if data.children and n > 1 then
return FindInTree(data.children, select(2, ...))
end
end
end
end
 
local function AddLevel(t, d)
local newLevel = {value = d.value, text = d.text, order = d.order or #t + 100, disabled = d.disabled}
tinsert(t, newLevel)
table.sort(t, function(a, b) return a.order < b.order end)
return newLevel
end
 
 
local function AddGroup(self, path, group, icon, re)
 
local tree = re or self.tree
if not tree then
tree = {}
self.tree = tree
end
 
local buildPath
 
for i, PathPart in pairs(path) do
buildPath = buildPath and buildPath.."\001"..PathPart.value or PathPart.value
 
local existingData = FindInTree(self.tree, string.split("\001", buildPath))
 
if not existingData then
local t = AddLevel(tree, PathPart)
if not path[i + 1] then
t.icon = icon
t.group = group
else
t.children = t.children or {}
tree = t.children
end
else
if not path[i + 1] then
if existingData.group then
error("Overwriting "..PathPart.text)
end
existingData.group = group
existingData.icon = icon
else
existingData.children = existingData.children or {}
tree = existingData.children
end
end
end
 
self:RefreshTree()
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()
local data = FindInTree(self.tree, string.split("\001", uniquevalue))
if data then
self:ReleaseChildren()
if data.group then
local scroll = AceGUI:Create("ScrollFrame")
scroll:SetLayout("Flow")
self:AddChild(scroll)
scroll:AddChildren(data.group())
scroll:DoLauout()
scroll:FixScroll()
self:DoLayout()
end
end
self:Fire("OnGroupSelected", uniquevalue)
end
 
local function SetSelected(self, value)
local status = self.status or self.localstatus
if status.selected ~= value then
status.selected = value
local data = FindInTree(self.tree, string.split("\001", value))
if data then
self:ReleaseChildren()
if data.group then
local scroll = AceGUI:Create("ScrollFrame")
scroll:SetLayout("Flow")
self:AddChild(scroll)
scroll:AddChildren(data.group())
scroll:FixScroll()
end
end
self:Fire("OnGroupSelected", value)
end
end
 
local function SetFont(self, font, size, flags)
self.fontO = self.fontO or CreateFont("UIFTreeFont")
self.fontO:SetFont(font, size, flags)
self.fontOH = self.fontOH or CreateFont("UIFTreeFontH")
self.fontOH:SetFont(font, size + 3, "OUTLINE")
self.useCustomFont = true
end
 
local function SetFontColor(self, color)
local font, size = GameFontNormal:GetFont()
if not self.fontO then
self.fontO = self.fontO or CreateFont("UIFTreeFont")
self.fontO:SetFont(font, size, "")
end
if not self.fontOH then
self.fontOH = self.fontOH or CreateFont("UIFTreeFontH")
local font, size = GameFontNormal:GetFont()
self.fontOH:SetFont(font, size + 3, "OUTLINE")
end
self.fontO:SetTextColor(unpack(color))
self.fontOH:SetTextColor(unpack(color))
self.useCustomFont = true
end
 
local function SetSubFont(self, font, size, flags)
self.subFont = self.subFont or CreateFont("UIFTreeSubFont")
self.subFont:SetFont(font, size, flags)
self.subFontH = self.subFontH or CreateFont("UIFTreeSubFontH")
self.subFontH:SetFont(font, size + 3, "OUTLINE")
self.useCustomSubFont = true
end
 
local function SetSubColor(self, color)
local font, size = GameFontNormal:GetFont()
if not self.subFont then
self.subFont = self.subFont or CreateFont("UIFTreeSubFont")
self.subFont:SetFont(font, size, "")
end
if not self.subFontH then
self.subFontH = self.subFontH or CreateFont("UIFTreeSubFontH")
self.subFontH:SetFont(font, size + 3, "OUTLINE")
end
self.subFontH:SetTextColor(unpack(color))
self.subFont:SetTextColor(unpack(color))
self.useCustomSubFont = true
end
 
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 UpdateButton(button, treeline, selected, canExpand, isExpanded)
local self = button.obj
local toggle = button.toggle
local frame = self.frame
local text = treeline.text or ""
local icon = treeline.icon
local iconCoords = treeline.iconCoords
local level = treeline.level
local value = treeline.value
local uniquevalue = treeline.uniquevalue
local disabled = treeline.disabled
 
button.treeline = treeline
button.value = value
button.uniquevalue = uniquevalue
if selected then
button:LockHighlight()
button.selected = true
else
button:UnlockHighlight()
button.selected = false
end
local normalTexture = button:GetNormalTexture()
local line = button.line
button.level = level
if ( level == 1 ) then
button:SetNormalFontObject("GameFontNormal")
button:SetHighlightFontObject("GameFontHighlight")
button.text:SetPoint("LEFT", (icon and 16 or 0) + 8, 2)
if self.useCustomFont then
button:SetNormalFontObject("UIFTreeFont")
button:SetHighlightFontObject("UIFTreeFontH")
end
else
button:SetNormalFontObject("GameFontHighlightSmall")
button:SetHighlightFontObject("GameFontHighlightSmall")
button.text:SetPoint("LEFT", (icon and 16 or 0) + 8 * level, 2)
if self.useCustomSubFont then
button:SetNormalFontObject("UIFTreeSubFont")
button:SetHighlightFontObject("UIFTreeSubFontH")
end
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 iconCoords then
button.icon:SetTexCoord(unpack(iconCoords))
else
button.icon:SetTexCoord(0, 1, 0, 1)
end
 
if canExpand then
if not isExpanded then
toggle:SetNormalTexture("Interface\\Buttons\\UI-PlusButton-UP")
toggle:SetPushedTexture("Interface\\Buttons\\UI-PlusButton-DOWN")
else
toggle:SetNormalTexture("Interface\\Buttons\\UI-MinusButton-UP")
toggle:SetPushedTexture("Interface\\Buttons\\UI-MinusButton-DOWN")
end
toggle:Show()
else
toggle:Hide()
end
end
 
local function 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 = (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 SetBorderColor(self, color)
self.border:SetBackdropBorderColor(unpack(color))
self.treeframe:SetBackdropBorderColor(unpack(color))
end
 
local function Constructor()
local self = AceGUI:Create("TreeGroup")
self.type = Type
 
self.OnRelease = OnRelease
 
self.AddGroup = AddGroup
self.SetSelected = SetSelected
self.Select = Select
 
self.RefreshTree = RefreshTree
 
self.SetFont = SetFont
self.SetFontColor = SetFontColor
self.SetSubFont = SetSubFont
self.SetSubColor = SetSubColor
self.SetBorderColor = SetBorderColor
 
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
mNameplates/Libs/LibGUIFactory-1.0/Widgets/UIF-ColorSelect.lua New file
0,0 → 1,47
local AceGUI = LibStub("AceGUI-3.0")
 
-- WoW APIs
local CreateFrame, UIParent = CreateFrame, UIParent
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: ShowUIPanel, HideUIPanel, ColorPickerFrame, OpacitySliderFrame
 
--------------------------
-- ColorPicker --
--------------------------
do
local Type = "UIF-ColorPicker"
local Version = 3
 
local function SetFont(self, font, size, flags)
self.text:SetFont(font, size, flags)
end
 
local function SetFontColor(self, color)
self.newColor = color
self.text:SetTextColor(unpack(color))
end
 
local function SetDisabled(self, disabled)
self.oldSetDisable(self, disabled)
if not disabled and self.newColor then
self.text:SetTextColor(unpack(self.newColor))
end
end
 
local function Constructor()
local self = AceGUI:Create("ColorPicker")
self.type = Type
 
self.oldSetDisable = self.SetDisabled
self.SetDisabled = SetDisabled
 
self.SetFont = SetFont
self.SetFontColor = SetFontColor
 
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
mNameplates/Libs/LibGUIFactory-1.0/Widgets/UIF-DropDownItems.lua New file
0,0 → 1,55
local AceGUI = LibStub("AceGUI-3.0")
 
do
local widgetType = "UIFDropdown-Item-Toggle"
local widgetVersion = 5
 
local function SetFont(self, font)
if _G[font] and _G[font].GetFont then
self.text:SetFontObject(font)
self.text:SetTextColor(_G[font]:GetTextColor())
local fontHeight = select(2, _G[font]:GetFont())
if fontHeight > self.frame:GetHeight() then
self.frame:SetHeight(fontHeight + 4)
self.highlight:SetHeight(fontHeight)
end
end
end
 
local function SetIcon(self, icon)
self.icon:SetTexture(icon)
if self.icon:GetTexture() then
self.icon:Show()
self.icon:SetWidth(self.frame:GetHeight() - 4)
else
self.icon:SetWidth(1)
self.icon:Hide()
end
end
 
local function Constructor()
local self = AceGUI:Create("Dropdown-Item-Toggle")
self.type = widgetType
 
local icon = self.frame:CreateTexture(nil, "OVERLAY")
icon:SetPoint("TOPLEFT", self.frame, "TOPLEFT", 18, -2)
icon:SetPoint("BOTTOMLEFT", self.frame, "BOTTOMLEFT", 18, 2 )
icon:Hide()
icon:SetWidth(1)
icon:SetTexCoord(0.07, 0.93, 0.07, 0.93)
self.icon = icon
 
self.check:SetPoint("LEFT", icon, "RIGHT", 2, 0)
self.text:SetPoint("TOPLEFT", self.check, "TOPRIGHT", 2, 0)
 
self.SetFont = SetFont
self.SetIcon = SetIcon
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion)
end
 
 
mNameplates/Libs/LibGUIFactory-1.0/Widgets/UIF-Label.lua New file
0,0 → 1,46
local AceGUI = LibStub("AceGUI-3.0")
 
 
do
local Type = "UIF-Label"
local Version = 2
 
local function OnRelease(self)
self.background:Hide()
end
 
local function SetBackground(self, color)
self.background:SetTexture(unpack(color))
self.background:Show()
end
 
local function Constructor()
local self = AceGUI:Create("Label")
self.type = Type
 
local frame = CreateFrame("Frame", nil, UIParent)
frame:Hide()
 
local t = frame:CreateTexture(nil, "BACKGROUND")
t:SetAllPoints()
t:Hide()
self.background = t
 
self.frame:SetParent(frame)
self.frame:Show()
self.frame:ClearAllPoints()
self.frame:SetAllPoints()
self.textframe = self.frame
self.frame = frame
 
self.label:SetJustifyV("MIDDLE")
 
self.SetBackground = SetBackground
self.OnRelease = OnRelease
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
mNameplates/Libs/LibGUIFactory-1.0/Widgets/UIF-NewLine.lua New file
0,0 → 1,28
local AceGUI = LibStub("AceGUI-3.0")
 
 
do
local Type = "UIF-NewLine"
local Version = 1
 
local function OnAcquire(sefl)
end
 
local function OnRelease(self)
end
 
local function Constructor()
local frame = CreateFrame("Frame")
self = {}
self.type = Type
self.frame = frame
 
self.OnAcquire = OnAcquire
self.OnRelease = OnRelease
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
mNameplates/Libs/LibGUIFactory-1.0/Widgets/UIF-Slider.lua New file
0,0 → 1,81
local AceGUI = LibStub("AceGUI-3.0")
 
-- Lua APIs
local min, max, floor = math.min, math.max, math.floor
local tonumber = tonumber
 
-- 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
 
--------------------------
-- Slider --
--------------------------
do
local Type = "UIF-Slider"
local Version = 3
 
local function OnAcquire(self)
self.OldOnAcquire(self)
self.slider:EnableMouseWheel(true)
end
 
local function SetDisabled(self, disabled)
self.oldSetDisable(self, disabled)
if not disabled and self.newColor then
self.label:SetTextColor(unpack(self.newColor))
self.lowtext:SetTextColor(unpack(self.newColor))
self.hightext:SetTextColor(unpack(self.newColor))
end
end
 
local function SetFont(self, font, size, flags)
self.label:SetFont(font, size, flags)
self.lowtext:SetFont(font, size, flags)
self.hightext:SetFont(font, size, flags)
self.editbox:SetFont(font, size, "none")
end
 
local function SetFontColor(self, color)
self.newColor = color
self.label:SetTextColor(unpack(color))
self.lowtext:SetTextColor(unpack(color))
self.hightext:SetTextColor(unpack(color))
end
 
local function Slider_OnMouseWheel(frame, v)
local self = frame.obj
if not self.disabled and IsShiftKeyDown() then
local value = self.value
if v > 0 then
value = min(value + (IsControlKeyDown() and 4 * self.step or self.step or 1), self.max)
else
value = max(value - (IsControlKeyDown() and 4 * self.step or self.step or 1), self.min)
end
self.slider:SetValue(value)
end
end
 
local function Constructor()
local self = AceGUI:Create("Slider")
self.type = Type
 
self.oldSetDisable = self.SetDisabled
self.SetDisabled = SetDisabled
 
self.SetFont = SetFont
self.SetFontColor = SetFontColor
 
self.OldOnAcquire = self.OnAcquire
self.OnAcquire = OnAcquire
 
self.slider:SetScript("OnMouseWheel", Slider_OnMouseWheel)
 
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
mNameplates/Libs/LibGUIFactory-1.0/Widgets/UIF-TabGroup.lua New file
0,0 → 1,41
local AceGUI = LibStub("AceGUI-3.0")
 
do
local Type = "UIF-TabGroup"
local Version = 3
 
local function SetFont(self, font, size, flags)
self.titletext:SetFont(font, size, flags)
end
 
local function SetFontColor(self, color)
self.titletext:SetTextColor(unpack(color))
end
 
local function SetBorderColor(self, color)
self.border:SetBackdropBorderColor(unpack(color))
end
 
local function SetBackColor(self, color)
self.border:SetBackdropColor(unpack(color))
end
 
local function Constructor()
local self = AceGUI:Create("TabGroup")
self.type = Type
 
self.SetBorderColor = SetBorderColor
self.SetBackColor = SetBackColor
self.SetFont = SetFont
self.SetFontColor = SetFontColor
 
 
self.border:ClearAllPoints()
self.border:SetPoint("TOPLEFT",self.titletext,"TOPLEFT",1,0)
self.border:SetPoint("BOTTOMRIGHT",self.frame,"BOTTOMRIGHT",-1,3)
 
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
mNameplates/Libs/LibGUIFactory-1.0/LibGUIFactory-1.0.lua New file
0,0 → 1,1094
local UIF_MAJOR, UIF_MINOR = "LibGUIFactory-1.0", 26
local UIF, oldminor = LibStub:NewLibrary(UIF_MAJOR, UIF_MINOR)
if not UIF then return end
 
local AceGUI = LibStub("AceGUI-3.0")
local LSM = LibStub("LibSharedMedia-3.0")
 
UIF.factories = UIF.factories or {}
UIF.embeds = {}
 
local InternalDrop, InternalButton
 
--
 
local function AddEmbed(name, func)
UIF.embeds[name] = func
end
 
local function Embed(obj)
for name, func in pairs(UIF.embeds) do
obj[name] = func
end
end
 
local function RecCheck(i, value, obj)
if not obj then return end
if type(value) == "table" then
if (obj[i]) then
assert(type(obj[i]) == "table", ("%q must be a table"):format(i))
for subOpt, subValue in pairs(value) do
RecCheck(subOpt, subValue, obj[i])
end
end
end
if type(obj) == "table" and obj[i] then
assert(type(obj[i]) == type(value), ("obj[%q] must be of type %s"):format(opt, type(value)))
if type(obj[i]) == "table" then
obj[i] = obj[i] or value
end
end
end
 
local function ValidateAndInsertDefaults(obj)
assert(obj and type(obj) == "table", "The provided object to be embeded with UIF-function must be a table")
 
-- For each in the defaults
for opt, value in pairs(UIF.defaults) do
 
-- If its a table
if type(value) == "table" then
 
-- Check if the incomming table have this index
if obj[opt] then
 
-- Check sp the type of the value is the same
assert(type(obj[opt]) == "table", ("[%q] must be a %s"):format(opt, type(value)))
 
-- For each subTable do the same check
for subOpt, subValue in pairs(value) do
RecCheck(subOpt, subValue, obj[subOpt])
end
end
else
if obj[opt] then
assert(type(obj[opt]) == type(value), ("obj[%q] must be of type %s"):format(opt, type(value)))
end
end
 
obj[opt] = obj[opt] or value
end
 
for opt, _ in pairs(obj) do
assert(UIF.defaults[opt], ("The setting %q is not a vailid setting"):format(opt))
end
end
 
function UIF:GetFactory(name, obj)
assert(not obj or type(obj) == "table", "Invalid factory object, it must be either nil or a table")
 
if self.factories[name] then return self.factories[name] end
 
newObj = {}
newObj.s = obj
newObj.name = name
 
ValidateAndInsertDefaults(newObj.s)
 
Embed(newObj)
 
self.factories[name] = newObj
 
return newObj
end
 
function UIF:UpdateFactory(name, obj)
assert(type(obj) == "table" or not obj, "Invalid factory object, it must be either nil or a table")
assert(self.factories[name], ("The factory %s does not exist"):format(name))
 
ValidateAndInsertDefaults(obj)
end
 
local function OnMouseEnter(widget, event)
local title, text = widget:GetUserData("enterTitle"), widget:GetUserData("enterText")
GameTooltip:SetOwner(widget.frame)
if title then
GameTooltip:AddLine(title)
end
GameTooltip:AddLine(text)
GameTooltip:Show()
end
 
local function OnMouseLeave(wdiget, event)
GameTooltip:Hide()
end
 
local function SetMouseOver(self, widget, title, text)
widget:SetUserData("enterTitle", title)
widget:SetUserData("enterText", text)
widget:SetCallback("OnEnter", OnMouseEnter)
widget:SetCallback("OnLeave", OnMouseLeave)
end
AddEmbed("SetMouseOver", SetMouseOver)
 
----------------------
-- Changing widget Methods
 
-- Used for update on release widgets
local function UpdateTrigger(widget, event, ...)
local self = widget:GetUserData("self")
local db = widget:GetUserData("db")
local key = widget:GetUserData("key")
local func = widget:GetUserData("extraCallback")
local TriggerGlobalUpdate = widget:GetUserData("TriggerGlobalUpdate")
 
if db then
if select("#", ...) > 1 then
for i = 1, select("#", ...) do
db[key] = db[key] or {}
if type(db[key]) ~= "table" then
db[key] = {}
end
db[key][i] = select(i, ...)
end
else
if widget.min then
local value = ...
if value < widget.min then value = widget.min end
if value > widget.max then value = widget.max end
db[key] = value
else
db[key] = ...
end
end
end
 
if widget.SetValue then
if widget.min then
local value = ...
if value < widget.min then value = widget.min end
if value > widget.max then value = widget.max end
widget:SetValue(value)
if widget.editbox then
widget.editbox:ClearFocus()
end
else
widget:SetValue(...)
end
end
if func then func(widget, event, ...) end
if widget.SetColor then
widget:SetColor(...)
end
if TriggerGlobalUpdate then
if self.valuesChangedCallback then
for i, func in pairs(self.valuesChangedCallback) do
func(self)
end
end
end
end
 
local function ConfirmPupup(widget, event, ...)
if not StaticPopupDialogs["AEGUIFACTORY_CONFIRM_DIALOG"] then
StaticPopupDialogs["AEGUIFACTORY_CONFIRM_DIALOG"] = {}
end
local t = StaticPopupDialogs["AEGUIFACTORY_CONFIRM_DIALOG"]
for k in pairs(t) do
t[k] = nil
end
t.text = "Are you sure?"
t.button1 = ACCEPT
t.button2 = CANCEL
local data = {...}
local dialog, oldstrata
t.OnAccept = function()
UpdateTrigger(widget, event, unpack(data))
if dialog and oldstrata then
dialog:SetFrameStrata(oldstrata)
end
end
t.OnCancel = function()
if dialog and oldstrata then
dialog:SetFrameStrata(oldstrata)
end
local self = widget:GetUserData("self")
local TriggerGlobalUpdate = widget:GetUserData("TriggerGlobalUpdate")
if TriggerGlobalUpdate then
if self.valuesChangedCallback then
for i, func in pairs(self.valuesChangedCallback) do
func(self)
end
end
end
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("AEGUIFACTORY_CONFIRM_DIALOG")
if dialog then
oldstrata = dialog:GetFrameStrata()
dialog:SetFrameStrata("TOOLTIP")
end
end
 
 
local function SetGUIOption(widget, event, ...)
local self = widget:GetUserData("self")
local db = widget:GetUserData("db")
local key = widget:GetUserData("key")
local UpdateOnMouseUp = widget:GetUserData("UpdateOnMouseUP")
local TriggerGlobalUpdate = widget:GetUserData("TriggerGlobalUpdate")
local func = widget:GetUserData("extraCallback")
local confirm = widget:GetUserData("confirm")
 
if confirm then ConfirmPupup(widget, event, ...) return end
 
if db and key then
if select("#", ...) > 1 then
for i = 1, select("#", ...) do
db[key] = db[key] or {}
if type(db[key]) ~= "table" then
db[key] = {}
end
db[key][i] = select(i, ...)
end
else
if widget.min then
local value = ...
if value < widget.min then value = widget.min end
if value > widget.max then value = widget.max end
db[key] = value
else
db[key] = ...
end
end
elseif db then
local item, value = ...
db[item] = value
end
 
if key and widget.SetValue then
if widget.min then
local value = ...
if value < widget.min then value = widget.min end
if value > widget.max then value = widget.max end
widget:SetValue(value)
else
widget:SetValue(...)
end
end
 
if widget.SetColor then
widget:SetColor(...)
end
 
if func then func(widget, event, ...) end
if TriggerGlobalUpdate then
if self.valuesChangedCallback and not UpdateOnMouseUp then
for i, func in pairs(self.valuesChangedCallback) do
func(self)
end
end
end
 
if key then AceGUI:ClearFocus() end
end
 
-- Internal
-- Get Label now supports a callback setting, incase you set to interactive so you can pass in an onClick handler to the label
local function GetLabel(lType, self, text, color, size, font, flags, interactive, relativeWidth, callback)
if text then assert(type(text) == "string" or type(text) == "number", ("%s-GuiFactory. %q must be a string or number"):format(self.name, "text")) end
if color then assert(type(color) == "table" and color[1] and #color > 2 and
type(color[1]) == "number" and
type(color[2]) == "number" and
type(color[3]) == "number", ("%s-GuiFactory. %q must be a numeric indexed table with at least 3 values, each of numeric type"):format(self.name, "color")) end
if size then assert(type(size) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "size")) end
if font then assert(type(font) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "font")) end
if flags then assert(type(flags) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "flags")) end
 
local s = self.s[lType]
 
color = color or s.fontColor or self.s.fontColor
local label
if interactive then
label = AceGUI:Create("InteractiveLabel")
label:SetCallback("OnClick", SetGUIOption)
label:SetUserData("extraCallback", callback)
else
label = AceGUI:Create("UIF-Label")
end
 
label:SetImage([[Interface\Icons\Achievement_Dungeon_Ulduar77_25man]], 0, 1, 0, 1)
label:SetImageSize(0, 0)
label:SetImage(nil)
label:SetFont(font or s.font or self.s.font, size or s.fontSize or self.s.fontSize, flags or s.fontFlags or self.s.fontFlags)
label:SetColor(unpack(color))
label:SetText(text)
label:SetRelativeWidth(relativeWidth or 1)
return label
end
 
--------------------
-- Labels
 
--- Create a TitleX object (Title1, Title2, Title3)
-- @paramsig [self ,] text [, color] [, size] [, font] [, flags] [, interactive]
-- @pram self Table that is the factory itself (optional when called with :Title1(..)
-- @param text Text to put in the label
-- @param color Table with 4 values 0.0-1.0 representing the RGB-value of the color
-- @param size Size of the font to use
-- @param font The fontfile to use
-- @param flags Font flags (THICKOUTLINE, OUTLINE, MONOCROME, NONE)
-- @interactive Boolean to tell if it should be an interactive text, meaning it triggers OnEnter and so on.
local function Title1(...)
return GetLabel("Title1", ...)
end
local function Title2(...)
return GetLabel("Title2", ...)
end
local function Title3(...)
return GetLabel("Title3", ...)
end
AddEmbed("Title1", Title1)
AddEmbed("Title2", Title2)
AddEmbed("Title3", Title3)
AddEmbed("Title", Title1)
AddEmbed("MainTitleLabel", Title1)
 
local function Text1(...)
return GetLabel("Text1", ...)
end
local function Text2(...)
return GetLabel("Text2", ...)
end
local function Text3(...)
return GetLabel("Text3", ...)
end
AddEmbed("Text1", Text1)
AddEmbed("Text2", Text2)
AddEmbed("Text3", Text3)
AddEmbed("NormalText", Text1)
 
--- Create a ListLevel1 object (ListLevel1, ListLevel2, ListLevel3)
-- @paramsig [self ,] text [, color] [, size] [, font] [, flags] [, interactive]
-- @pram self Table that is the factory itself (optional when called with :Title1(..)
-- @param text Text to put in the label
-- @param color Table with 4 values 0.0-1.0 representing the RGB-value of the color
-- @param size Size of the font to use
-- @param font The fontfile to use
-- @param flags Font flags (THICKOUTLINE, OUTLINE, MONOCROME, NONE)
-- @interactive Boolean to tell if it should be an interactive text, meaning it triggers OnEnter and so on.
local function ListLevel1(self, text, color, size, font, flags, interactive)
return GetLabel("ListLevel1", self, text, color, size, font, flags, interactive)
end
local function ListLevel1(self, text, color, size, font, flags, interactive)
return GetLabel("ListLevel2", self, text, color, size, font, flags, interactive)
end
local function ListLevel1(self, text, color, size, font, flags, interactive)
return GetLabel("ListLevel3", self, text, color, size, font, flags, interactive)
end
AddEmbed("ListLevel1", ListLevel1)
AddEmbed("ListLevel3", ListLevel2)
AddEmbed("ListLevel2", ListLevel3)
AddEmbed("ListText", ListLevel1)
 
---------------------
-- Frame
 
-- Create a main window for your GUI
-- @paramsig [self, ] text
-- @param self Table that is the factory itself, should not be passed when used lik Factory:Frame(...)
-- @param text Text to put in the title area of the window
local function Frame(self, text)
local s = self.s["Frame"]
 
local group = AceGUI:Create("UIF-Frame")
group:SetTitleFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags)
group:SetTitleFontColor(s.fontColor or self.s.fontColor)
group:SetBorderColor(s.borderColor or self.s.borderColor)
group:SetBackColor(s.bgColor or self.s.bgColor)
group:SetTitle(text)
 
local button = self:Button("")
 
group:SetButton(button)
 
return group
end
AddEmbed("Frame", Frame)
 
---------------------
-- Dropdown group
 
local function DropdownGroup(self, text)
local s = self.s["DropdownGroup"]
 
local group = AceGUI:Create("UIF-DropdownGroup")
group:SetFullWidth(true)
group:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags)
group:SetFontColor(s.fontColor or self.s.fontColor)
group:SetBorderColor(s.borderColor or self.s.borderColor)
 
group:SetTitle(text)
 
local drop = InternalDrop(self)
group:SetDropdownWidget(drop)
return group
end
AddEmbed("DropdownGroup", DropdownGroup)
 
----------------------
-- Tree group
 
local function TreeGroup(self)
local s = self.s["TreeGroup"]
 
local group = AceGUI:Create("UIF-TreeGroup")
group:SetFullWidth(true)
group:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags)
group:SetFontColor(s.fontColor or self.s.fontColor)
group:SetSubFont(s.subFont or self.s.font, s.subFontSize or self.s.fontSize, s.subFontFlags or self.s.fontFlags)
group:SetSubColor(s.subColor or self.s.fontColor)
group:SetBorderColor(s.borderColor or self.s.borderColor)
return group
end
AddEmbed("TreeGroup", TreeGroup)
 
----------------------
-- Tab group
 
local function TGroup(tType, self, text)
if text then assert(type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text")) end
 
local s = self.s[tType]
 
local group = AceGUI:Create("UIF-TabGroup")
 
group:SetBorderColor(s.borderColor or self.s.borderColor)
group:SetBackColor(s.bgColor)
group:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags)
group:SetFontColor(s.fontColor or self.s.fontColor)
 
group:SetTitle(text)
 
group:SetFullWidth(true)
group:SetLayout("Flow")
 
return group
end
 
local function TabGroup1(self, text)
return TGroup("TabGroup1", self, text)
end
local function TabGroup2(self, text)
return TGroup("TabGroup2", self, text)
end
local function TabGroup2(self, text)
return TGroup("TabGroup3", self, text)
end
AddEmbed("TabGroup1", TabGroup1)
AddEmbed("TabGroup", TabGroup1) -- Backwards compability
AddEmbed("TabGroup2", TabGroup2)
AddEmbed("TabGroup3", TabGroup3)
 
----------------------
-- Inline group
 
local function IGroup(gType, self, text, bgColor, borderColor)
if text then assert(type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text")) end
if bgColor then assert(type(bgColor) == "table" and #bgColor > 2 and
type(bgColor[1]) == "number" and
type(bgColor[2]) == "number" and
type(bgColor[3]) == "number", ("%s-GuiFactory. %q must be a numeric indexed table with at least 3 values, each of numeric type"):format(self.name, "bgColor")) end
if borderColor then assert(type(borderColor) == "table" and #borderColor > 2 and
type(borderColor[1]) == "number" and
type(borderColor[2]) == "number" and
type(borderColor[3]) == "number", ("%s-GuiFactory. %q must be a numeric indexed table with at least 3 values, each of numeric type"):format(self.name, "borderColor")) end
 
local s = self.s[gType]
 
local group = AceGUI:Create("UIF-InlineGroup")
group:SetLayout("Flow")
group:SetFullWidth(true)
group:SetTitle(text)
group:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags)
group:SetFontColor(s.fontColor or self.s.fontColor)
group:SetBGColor(bgColor or s.bgColor or self.s.bgColor)
group:SetBorderColor(borderColor or s.borderColor or self.s.borderColor)
 
return group
end
 
local function InlineGroup1(self, text, bgColor, borderColor)
return IGroup("InlineGroup1", self, text, bgColor, borderColor)
end
local function InlineGroup2(self, text, bgColor, borderColor)
return IGroup("InlineGroup2", self, text, bgColor, borderColor)
end
local function InlineGroup3(self, text, bgColor, borderColor)
return IGroup("InlineGroup3", self, text, bgColor, borderColor)
end
AddEmbed("InlineGroup1", InlineGroup1)
AddEmbed("InlineGroup2", InlineGroup2)
AddEmbed("InlineGroup3", InlineGroup3)
AddEmbed("InlineGroup", InlineGroup1)
 
-- Mewline
local function NewLine(self, height)
local t = AceGUI:Create("UIF-NewLine")
t:SetHeight(height or 2)
t:SetFullWidth(true)
return t
end
AddEmbed("NewLine", NewLine)
 
local function Spacer(self, width)
local t = AceGUI:Create("UIF-NewLine")
t:SetWidth(width or 2)
t:SetFullWidth(false)
t:SetHeight(10)
return t
end
AddEmbed("Spacer", Spacer)
 
-- Changing Widgets
 
local function Slider(self, text, db, key, min, max, step, callback, relativeWidth)
assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text"))
assert(db and type(db) == "table", ("%s-GuiFactory. %q must be a table"):format(self.name, "db"))
assert(key, ("%s-GuiFactory. %q must be supplied"):format(self.name, "key"))
assert(db[key], ("%s-GuiFactory. %q does not contain %q"):format(self.name, "db", key))
if callback then assert(type(callback) == "function", ("%s-GuiFactory. %q must be a function"):format(self.name, "callback")) end
if min then assert(type(min) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "min")) end
if max then assert(type(max) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "max")) end
if step then assert(type(step) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "step")) end
if relativeWidth then assert(type(relativeWidth) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "relativeWidth")) end
 
local s = self.s["Slider"]
 
local slider = AceGUI:Create("UIF-Slider")
slider:SetLabel(text)
slider:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags)
slider:SetFontColor(s.fontColor or self.s.fontColor)
slider:SetSliderValues(min or 0, max or 100, step or 1)
slider:SetValue(db[key])
slider:SetUserData("db", db)
slider:SetUserData("key", key)
slider:SetUserData("extraCallback", callback)
slider:SetUserData("self", self)
slider:SetUserData("UpdateOnMouseUP", true)
slider:SetCallback("OnValueChanged", SetGUIOption)
slider:SetCallback("OnMouseUp", UpdateTrigger)
 
if relativeWidth then slider:SetRelativeWidth(relativeWidth) end
 
return slider
end
AddEmbed("Slider", Slider)
 
local function PositionSlider(self, type, text, db, key, step, callback, relativeWidth)
local min, max
if string.lower(type) == "x" then
min = -floor(GetScreenWidth() * UIParent:GetEffectiveScale())
max = floor(GetScreenWidth() * UIParent:GetEffectiveScale())
else
min = -floor(GetScreenHeight() * UIParent:GetEffectiveScale())
max = floor(GetScreenHeight() * UIParent:GetEffectiveScale())
end
 
return Slider(self, text, db, key, min, max, step, callback, relativeWidth)
end
AddEmbed("PositionSlider", PositionSlider)
 
local function CheckBox(self, text, db, key, callback, description, relativeWidth, globalUpdate)
assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text"))
assert(db and type(db) == "table", ("%s-GuiFactory. %q must be a table"):format(self.name, "db"))
assert(key, ("%s-GuiFactory. %q must be supplied"):format(self.name, "key"))
if callback then assert(type(callback) == "function", ("%s-GuiFactory. %q must be a function"):format(self.name, "callback")) end
if relativeWidth then assert(type(relativeWidth) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "relativeWidth")) end
 
local s = self.s["CheckBox"]
 
local check = AceGUI:Create("UIF-CheckBox")
check:SetFullWidth(true)
check:SetLabel(text)
check:SetValue(db[key])
check:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags)
check:SetFontColor(s.fontColor or self.s.fontColor)
if description then
check:SetDescription(description)
end
 
check:SetUserData("db", db)
check:SetUserData("key", key)
check:SetUserData("extraCallback", callback)
check:SetUserData("self", self)
check:SetUserData("TriggerGlobalUpdate", globalUpdate)
check:SetCallback("OnValueChanged", SetGUIOption)
 
if relativeWidth then check:SetRelativeWidth(relativeWidth) end
 
return check
end
AddEmbed("CheckBox", CheckBox)
 
local function ColorSelect(self, text, db, key, callback, hasAlpha, relativeWidth)
assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text"))
assert(db and type(db) == "table", ("%s-GuiFactory. %q must be a table"):format(self.name, "db"))
assert(key, ("%s-GuiFactory. %q must be supplied"):format(self.name, "key"))
if callback then assert(type(callback) == "function", ("%s-GuiFactory. %q must be a function"):format(self.name, "callback")) end
if hasAlpha then assert(hasAlpha and type(hasAlpha) == "boolean", ("%s-GuiFactory. %q must be a boolean"):format(self.name, "hasAlpha")) end
if relativeWidth then assert(type(relativeWidth) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "relativeWidth")) end
 
local s = self.s["CheckBox"]
 
local color = AceGUI:Create("UIF-ColorPicker")
color:SetLabel(text)
color:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags)
color:SetFontColor(s.fontColor or self.s.fontColor)
if db[key] and type(db[key]) == "table" then
color:SetColor(unpack(db[key]))
end
color:SetHasAlpha(hasAlpha)
 
color:SetUserData("db", db)
color:SetUserData("key", key)
color:SetUserData("extraCallback", callback)
color:SetUserData("self", self)
color:SetCallback("OnValueChanged", SetGUIOption)
color:SetUserData("UpdateOnMouseUP", true)
color:SetCallback("OnValueConfirmed", UpdateTrigger)
 
if relativeWidth then color:SetRelativeWidth(relativeWidth) end
 
return color
end
AddEmbed("ColorSelect", ColorSelect)
 
-----------------------
-- Other
 
InternalButton = function(self)
local s = self.s["Button"]
 
local color = color or s.fontColor or self.s.fontColor
 
local button = AceGUI:Create("UIF-Button")
button:SetText(text)
button:SetFont(font or s.font or self.s.font, size or s.fontSize or self.s.fontSize, flags or s.fontFlags or self.s.fontFlags)
button:SetFontColor(color)
 
return button
end
 
local function Button(self, text, callback, font, size, flags, color, relativeWidth)
assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text"))
if color then assert(type(color) == "table" and color[1] and #color > 2 and
type(color[1]) == "number" and
type(color[2]) == "number" and
type(color[3]) == "number", ("%s-GuiFactory. %q must be a numeric indexed table with at least 3 values, each of numeric type"):format(self.name, "color")) end
if size then assert(type(size) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "size")) end
if font then assert(type(font) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "font")) end
if flags then assert(type(flags) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "flags")) end
 
local s = self.s["Button"]
 
color = color or s.fontColor or self.s.fontColor
 
local button = AceGUI:Create("UIF-Button")
button:SetText(text)
button:SetFont(font or s.font or self.s.font, size or s.fontSize or self.s.fontSize, flags or s.fontFlags or self.s.fontFlags)
button:SetFontColor(color)
 
button:SetUserData("self", self)
button:SetUserData("extraCallback", callback)
button:SetCallback("OnClick", SetGUIOption)
button:SetUserData("UpdateOnMouseUP", true)
button:SetCallback("OnMouseUp", UpdateTrigger)
 
if not relativeWidth then
button:SetWidth(button.text:GetStringWidth() + 30)
else
button:SetRelativeWidth(relativeWidth)
end
 
return button
end
AddEmbed("Button", Button)
 
----------------------
-- Dropdown
 
InternalDrop = function(self, text, callback, list, relativeWidth)
local s = self.s["Dropdown"]
 
local drop = AceGUI:Create("UIF-Dropdown")
drop:SetItemFont(s.itemFont or self.s.font, s.itemFontSize or self.s.fontSize, s.itemFontFlags or self.s.fontFlags)
drop:SetItemFontColor(s.itemFontColor or self.s.fontColor)
drop:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags)
drop:SetFontColor(s.fontColor or self.s.fontColor)
 
drop:SetUserData("self", self)
drop:SetLabel(text)
drop:SetList(list)
drop:SetUserData("extraCallback", callback)
drop:SetCallback("OnValueChanged", SetGUIOption)
if relativeWidth then drop:SetRelativeWidth(relativeWidth) end
 
return drop
end
AddEmbed("SimpleDropdown", InternalDrop)
 
local function Dropdown(self, text, db, key, callback, list, relativeWidth, globalUpdate)
assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text"))
assert(db and type(db) == "table", ("%s-GuiFactory. %q must be a table"):format(self.name, "db"))
assert(key, ("%s-GuiFactory. %q must be supplied"):format(self.name, "key"))
if callback then assert(type(callback) == "function", ("%s-GuiFactory. %q must be a function"):format(self.name, "callback")) end
if relativeWidth then assert(type(relativeWidth) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "relativeWidth")) end
 
local drop = InternalDrop(self)
drop:SetLabel(text)
 
drop:SetUserData("db", db)
drop:SetUserData("key", key)
drop:SetUserData("self", self)
drop:SetList(list)
drop:SetUserData("extraCallback", callback)
drop:SetCallback("OnValueChanged", SetGUIOption)
drop:SetValue(db[key])
 
drop:SetUserData("TriggerGlobalUpdate", globalUpdate)
 
if relativeWidth then drop:SetRelativeWidth(relativeWidth) end
 
return drop
end
AddEmbed("Dropdown", Dropdown)
 
local function MultiSelectDropdown(self, text, db, callback, list, relativeWidth)
assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text"))
assert(db and type(db) == "table", ("%s-GuiFactory. %q must be a table"):format(self.name, "db"))
if callback then assert(type(callback) == "function", ("%s-GuiFactory. %q must be a function"):format(self.name, "callback")) end
if relativeWidth then assert(type(relativeWidth) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "relativeWidth")) end
 
local drop = InternalDrop(self)
drop:SetLabel(text)
drop:SetMultiselect(true)
 
drop:SetUserData("db", db)
drop:SetUserData("self", self)
if list then
drop:SetList(list)
for i in pairs(list) do
if db[i] then drop:SetItemValue(i, true) end
end
end
drop:SetUserData("extraCallback", callback)
drop:SetCallback("OnValueChanged", SetGUIOption)
 
if relativeWidth then drop:SetRelativeWidth(relativeWidth) end
 
return drop
end
AddEmbed("MultiSelectDropdown", MultiSelectDropdown)
 
local function LSMDropdown(self, dtype, text, db, key, callback, relativeWidth)
assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text"))
assert(db and type(db) == "table", ("%s-GuiFactory. %q must be a table"):format(self.name, "db"))
assert(key, ("%s-GuiFactory. %q must be supplied"):format(self.name, "key"))
if callback then assert(type(callback) == "function", ("%s-GuiFactory. %q must be a function"):format(self.name, "callback")) end
if relativeWidth then assert(type(relativeWidth) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "relativeWidth")) end
 
local drop
local dtype = string.lower(dtype)
if dtype == "statusbar" then
drop = AceGUI:Create("LSM30_Statusbar")
drop:SetList(LSM:HashTable("statusbar"))
elseif dtype == "font" then
drop = AceGUI:Create("LSM30_Font")
drop:SetList(LSM:HashTable("font"))
elseif dtype == "background" then
drop = AceGUI:Create("LSM30_Background")
drop:SetList(LSM:HashTable("background"))
elseif dtype == "border" then
drop = AceGUI:Create("LSM30_Border")
drop:SetList(LSM:HashTable("border"))
elseif dtype == "sound" then
drop = AceGUI:Create("LSM30_Sound")
drop:SetList(LSM:HashTable("sound"))
else
assert(drop ~= nil, ("%s-GuiFactory. %q is not a valid LSM dropdown."):format(self.name, "dtype"))
end
 
 
drop:SetLabel(text)
drop:SetValue(db[key])
 
drop:SetUserData("db", db)
drop:SetUserData("key", key)
drop:SetUserData("extraCallback", callback)
drop:SetUserData("self", self)
drop:SetCallback("OnValueChanged", SetGUIOption)
 
if relativeWidth then drop:SetRelativeWidth(relativeWidth) end
 
return drop
end
AddEmbed("LSMDropdown", LSMDropdown)
 
-- Profile
local AceProfileOption
do
local function GetAllPorfiles(db)
local profiles = {
["Default"] = "Default",
[db.keys.char] = db.keys.char,
[db.keys.realm] = db.keys.realm,
[db.keys.class] = UnitClass("player")
}
local ExistingProfiles = {}
local count = 0
 
for i, profileName in pairs(db:GetProfiles()) do
profiles[profileName] = profileName
count = count + 1
end
 
return profiles, count
end
 
local function GetExistingProfiles(db, nocurrent)
local profiles = {}
local currentProfile = db:GetCurrentProfile()
local count = 0
 
for i, profileName in pairs(db:GetProfiles()) do
if not (nocurrent and profileName == currentProfile) then
profiles[profileName] = profileName
count = count + 1
end
end
 
return profiles, count
end
 
local function RefreshProfileLists(widget)
local SelectProfile = widget:GetUserData("SelectProfile")
if not SelectProfile then return end
local CopyProfile = widget:GetUserData("CopyProfile")
local DeleteProfile = widget:GetUserData("DeleteProfile")
local db = SelectProfile:GetUserData("Database")
 
local profiles, count = GetAllPorfiles(db)
SelectProfile:SetList(profiles)
SelectProfile:SetValue(db:GetCurrentProfile())
profiles, count = GetExistingProfiles(db, true)
CopyProfile:SetList(profiles)
CopyProfile:SetDisabled(count == 0)
CopyProfile:SetValue()
DeleteProfile:SetList(profiles)
DeleteProfile:SetDisabled(count == 0)
DeleteProfile:SetValue()
end
 
-- Create a group containing options to handle AceDB-3.0 profiles.
-- @paramsig [self ,] db
-- @param self Table that is the factory itself, Not required when used via Factory:AceProfileOption(...)
-- @param db AceDB-3.0 database object to create the profile options for.
AceProfileOption = function(self, db)
assert(db and db.ResetDB, ("%s-GuiFactory. %q must proper AceDB object."):format(self.name, "db"))
 
local group = self:InlineGroup("Profile Settings")
local profiles, count, text
 
local SelectProfile = InternalDrop(self)
SelectProfile:SetLabel("Profiles")
SelectProfile:SetUserData("Database", db)
SelectProfile:SetCallback("OnValueChanged", function(widget, event, value)
widget:GetUserData("Database"):SetProfile(value)
RefreshProfileLists(group)
end)
group:AddChild(SelectProfile)
 
local ResetProfile = InternalButton(self)
ResetProfile:SetText("Reset")
ResetProfile:SetWidth(ResetProfile.text:GetStringWidth() + 30)
ResetProfile:SetUserData("Database", db)
ResetProfile:SetUserData("self", self)
ResetProfile:SetUserData("extraCallback", function(widget, event)
widget:GetUserData("Database"):ResetProfile()
end)
ResetProfile:SetCallback("OnClick", SetGUIOption)
ResetProfile:SetUserData("confirm", true)
group:AddChild(ResetProfile)
 
group:AddChild(self:NewLine(15))
group:AddChild(self:NormalText("Copy a profile and replace the current profiles settings."))
local CopyProfile = InternalDrop(self)
CopyProfile:SetLabel("Copy Profile")
CopyProfile:SetUserData("Database", db)
CopyProfile:SetCallback("OnValueChanged", function(widget, event, value)
local db = widget:GetUserData("Database")
db:CopyProfile(value)
RefreshProfileLists(group)
end)
group:AddChild(CopyProfile)
 
group:AddChild(self:NewLine(15))
group:AddChild(self:NormalText("Delete one of the existing profiles"))
local DeleteProfile = InternalDrop(self)
DeleteProfile:SetLabel("Delete Profile")
DeleteProfile:SetUserData("Database", db)
DeleteProfile:SetUserData("self", self)
DeleteProfile:SetUserData("extraCallback", function(widget, event, value)
local db = widget:GetUserData("Database")
if value then
db:DeleteProfile(value)
end
RefreshProfileLists(group)
end)
DeleteProfile:SetCallback("OnValueChanged", SetGUIOption)
DeleteProfile:SetUserData("confirm", true)
group:AddChild(DeleteProfile)
 
group:AddChild(self:NewLine(15))
group:AddChild(self:NormalText("Create a new profile, it will then become the active profile."))
local CreateProfile = AceGUI:Create("EditBox")
CreateProfile:SetLabel("Create Profile")
CreateProfile:SetUserData("Database", db)
CreateProfile:SetCallback("OnEnterPressed", function(widget, event, value)
local db = widget:GetUserData("Database")
db:SetProfile(value)
widget.editbox:ClearFocus()
widget:SetText()
RefreshProfileLists(group)
end)
group:AddChild(CreateProfile)
 
group:SetUserData("SelectProfile", SelectProfile)
group:SetUserData("CopyProfile", CopyProfile)
group:SetUserData("DeleteProfile", DeleteProfile)
 
RefreshProfileLists(group)
 
return group
end
end
AddEmbed("AceProfileOption", AceProfileOption)
 
local function SetValuesChangedCallback(self, func)
assert(type(func) == "function", "The callback must be a function")
self.valuesChangedCallback = self.valuesChangedCallback or {}
tinsert(self.valuesChangedCallback, func)
end
AddEmbed("SetValuesChangedCallback", SetValuesChangedCallback)
 
for fName, factory in pairs(UIF.factories) do
Embed(factory)
end
 
-- Defaults
local defaultFont, defualtFondSize, defaultFontFlags = GameFontNormal:GetFont()
 
UIF.defaults = {
font = defaultFont,
fontSize = defualtFondSize,
fontColor = {177/255, 219/255, 255/255},
fontFlags = defaultFontFlags,
borderColor = {0.2,0.3,0.37,1},
bgColor = {0.11,0.16,0.19,1},
 
MainTitle = {
fontSize = 30,
fontColor = {0.4, 0.6, 0.8},
fontFlags = "OUTLINE"
},
 
-- Titles
Title1 = {
fontSize = 30,
fontColor = {255/255, 248/255, 53/255},
fontFlags = "OUTLINE"
},
Title2 = {
fontSize = 20,
fontColor = {18/255, 157/255, 143/255},
fontFlags = "OUTLINE"
},
Title3 = {
fontSize = 18,
fontColor = {18/255, 157/255, 143/255},
fontFlags = "OUTLINE"
},
 
-- Mornal texts
Text1 = {
fontSize = 16,
fontColor = {177/255, 219/255, 255/255},
},
Text2 = {
},
Text3 = {
},
 
-- Lists
ListLevel1 = {
fontSize = 16,
fontColor = {0.96, 0.93, 0.49},
},
ListLevel2 = {
},
ListLevel3 = {
},
 
-- Frame
Frame = {
fontSize = 25,
bgColor = {0.11,0.16,0.19,0.8},
},
DropdownGroup = {
},
Dropdown = {
itemFontSize = 18,
},
TreeGroup = {
fontColor = {0.4, 0.6, 0.8},
},
TabGroup1 = {
fontSize = 20,
tabFontSize = 35,
bgColor = {0.11,0.16,0.19,1},
borderColor = {0.2,0.3,0.37,1},
},
TabGroup2 = {
fontSize = 20,
fontFlags = "OUTLINE",
bgColor = {40/255, 45/255, 70/255},
borderColor = {81/255, 96/255, 106/255},
fontColor = {207/255, 218/255, 85/255},
},
TabGroup3 = {
fontSize = 20,
fontFlags = "OUTLINE",
bgColor = {40/255, 45/255, 70/255},
borderColor = {81/255, 96/255, 106/255},
fontColor = {207/255, 218/255, 85/255},
},
InlineGroup1 = {
fontFlags = "OUTLINE",
fontSize = 22,
},
InlineGroup2 = {
bgColor = {40/255, 45/255, 70/255},
borderColor = {81/255, 96/255, 106/255},
fontColor = {207/255, 218/255, 85/255},
fontSize = 22,
},
InlineGroup3 = {
bgColor = {40/255, 55/255, 75/255},
borderColor = {81/255, 96/255, 106/255},
fontColor = {207/255, 100/255, 85/255},
fontSize = 20,
},
Button = {
},
Slider = {
},
CheckBox = {
},
}
\ No newline at end of file
mNameplates/Libs/LibStub/LibStub.lua New file
0,0 → 1,30
-- LibStub is a simple versioning stub meant for use in Libraries. http://www.wowace.com/wiki/LibStub for more info
-- LibStub is hereby placed in the Public Domain Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel, joshborke
local LIBSTUB_MAJOR, LIBSTUB_MINOR = "LibStub", 2 -- NEVER MAKE THIS AN SVN REVISION! IT NEEDS TO BE USABLE IN ALL REPOS!
local LibStub = _G[LIBSTUB_MAJOR]
 
if not LibStub or LibStub.minor < LIBSTUB_MINOR then
LibStub = LibStub or {libs = {}, minors = {} }
_G[LIBSTUB_MAJOR] = LibStub
LibStub.minor = LIBSTUB_MINOR
 
function LibStub:NewLibrary(major, minor)
assert(type(major) == "string", "Bad argument #2 to `NewLibrary' (string expected)")
minor = assert(tonumber(strmatch(minor, "%d+")), "Minor version must either be a number or contain a number.")
 
local oldminor = self.minors[major]
if oldminor and oldminor >= minor then return nil end
self.minors[major], self.libs[major] = minor, self.libs[major] or {}
return self.libs[major], oldminor
end
 
function LibStub:GetLibrary(major, silent)
if not self.libs[major] and not silent then
error(("Cannot find a library instance of %q."):format(tostring(major)), 2)
end
return self.libs[major], self.minors[major]
end
 
function LibStub:IterateLibraries() return pairs(self.libs) end
setmetatable(LibStub, { __call = LibStub.GetLibrary })
end
mNameplates/Libs/LibStub/LibStub.toc New file
0,0 → 1,13
## Interface: 20400
## Title: Lib: LibStub
## Notes: Universal Library Stub
## Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel
## X-Website: http://jira.wowace.com/browse/LS
## X-Category: Library
## X-License: Public Domain
## X-Curse-Packaged-Version: 1.0
## X-Curse-Project-Name: LibStub
## X-Curse-Project-ID: libstub
## X-Curse-Repository-ID: wow/libstub/mainline
 
LibStub.lua
mNameplates/Libs/AceGUI-3.0-SharedMediaWidgets/widget.xml New file
0,0 → 1,9
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Script file="prototypes.lua" />
<Script file="FontWidget.lua" />
<Script file="SoundWidget.lua" />
<Script file="StatusbarWidget.lua" />
<Script file="BorderWidget.lua" />
<Script file="BackgroundWidget.lua" />
</Ui>
\ No newline at end of file
mNameplates/Libs/AceGUI-3.0-SharedMediaWidgets/BackgroundWidget.lua New file
0,0 → 1,231
-- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0
-- Widget created by Yssaril
 
local AceGUI = LibStub("AceGUI-3.0")
local Media = LibStub("LibSharedMedia-3.0")
 
local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0")
 
do
local widgetType = "LSM30_Background"
local widgetVersion = 9
 
local contentFrameCache = {}
local function ReturnSelf(self)
self:ClearAllPoints()
self:Hide()
self.check:Hide()
table.insert(contentFrameCache, self)
end
 
local function ContentOnClick(this, button)
local self = this.obj
self:Fire("OnValueChanged", this.text:GetText())
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function ContentOnEnter(this, button)
local self = this.obj
local text = this.text:GetText()
local background = self.list[text] ~= text and self.list[text] or Media:Fetch('background',text)
self.dropdown.bgTex:SetTexture(background)
end
 
local function GetContentLine()
local frame
if next(contentFrameCache) then
frame = table.remove(contentFrameCache)
else
frame = CreateFrame("Button", nil, UIParent)
--frame:SetWidth(200)
frame:SetHeight(18)
frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD")
frame:SetScript("OnClick", ContentOnClick)
frame:SetScript("OnEnter", ContentOnEnter)
local check = frame:CreateTexture("OVERLAY")
check:SetWidth(16)
check:SetHeight(16)
check:SetPoint("LEFT",frame,"LEFT",1,-1)
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check")
check:Hide()
frame.check = check
local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite")
 
local font, size = text:GetFont()
text:SetFont(font,size,"OUTLINE")
 
text:SetPoint("LEFT", check, "RIGHT", 1, 0)
text:SetPoint("RIGHT", frame, "RIGHT", -2, 0)
text:SetJustifyH("LEFT")
text:SetText("Test Test Test Test Test Test Test")
frame.text = text
frame.ReturnSelf = ReturnSelf
end
frame:Show()
return frame
end
 
local function OnAcquire(self)
self:SetHeight(44)
self:SetWidth(200)
end
 
local function OnRelease(self)
self:SetText("")
self:SetLabel("")
self:SetDisabled(false)
 
self.value = nil
self.list = nil
self.open = nil
self.hasClose = nil
 
self.frame:ClearAllPoints()
self.frame:Hide()
end
 
local function SetValue(self, value) -- Set the value to an item in the List.
if self.list then
self:SetText(value or "")
end
self.value = value
end
 
local function GetValue(self)
return self.value
end
 
local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs)
self.list = list or Media:HashTable("background")
end
 
 
local function SetText(self, text) -- Set the text displayed in the box.
self.frame.text:SetText(text or "")
local background = self.list[text] ~= text and self.list[text] or Media:Fetch('background',text)
 
self.frame.displayButton:SetBackdrop({bgFile = background,
edgeFile = "Interface/Tooltips/UI-Tooltip-Border",
edgeSize = 16,
insets = { left = 4, right = 4, top = 4, bottom = 4 }})
end
 
local function SetLabel(self, text) -- Set the text for the label.
self.frame.label:SetText(text or "")
end
 
local function AddItem(self, key, value) -- Add an item to the list.
self.list = self.list or {}
self.list[key] = value
end
local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>>
 
local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>>
local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>>
local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>>
 
local function SetDisabled(self, disabled) -- Disable the widget.
self.disabled = disabled
if disabled then
self.frame:Disable()
self.frame.displayButton:SetBackdropColor(.2,.2,.2,1)
else
self.frame:Enable()
self.frame.displayButton:SetBackdropColor(1,1,1,1)
end
end
 
local function textSort(a,b)
return string.upper(a) < string.upper(b)
end
 
local sortedlist = {}
local function ToggleDrop(this)
local self = this.obj
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
AceGUI:ClearFocus()
else
AceGUI:SetFocus(self)
self.dropdown = AGSMW:GetDropDownFrame()
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT")
for k, v in pairs(self.list) do
sortedlist[#sortedlist+1] = k
end
table.sort(sortedlist, textSort)
for i, k in ipairs(sortedlist) do
local f = GetContentLine()
f.text:SetText(k)
--print(k)
if k == self.value then
f.check:Show()
end
f.obj = self
f.dropdown = self.dropdown
self.dropdown:AddFrame(f)
end
wipe(sortedlist)
end
end
 
local function ClearFocus(self)
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function OnHide(this)
local self = this.obj
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function Drop_OnEnter(this)
this.obj:Fire("OnEnter")
end
 
local function Drop_OnLeave(this)
this.obj:Fire("OnLeave")
end
 
local function Constructor()
local frame = AGSMW:GetBaseFrameWithWindow()
local self = {}
 
self.type = widgetType
self.frame = frame
frame.obj = self
frame.dropButton.obj = self
frame.dropButton:SetScript("OnEnter", Drop_OnEnter)
frame.dropButton:SetScript("OnLeave", Drop_OnLeave)
frame.dropButton:SetScript("OnClick",ToggleDrop)
frame:SetScript("OnHide", OnHide)
 
self.alignoffset = 31
 
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
self.ClearFocus = ClearFocus
self.SetText = SetText
self.SetValue = SetValue
self.GetValue = GetValue
self.SetList = SetList
self.SetLabel = SetLabel
self.SetDisabled = SetDisabled
self.AddItem = AddItem
self.SetMultiselect = SetMultiselect
self.GetMultiselect = GetMultiselect
self.SetItemValue = SetItemValue
self.SetItemDisabled = SetItemDisabled
self.ToggleDrop = ToggleDrop
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion)
 
end
mNameplates/Libs/AceGUI-3.0-SharedMediaWidgets/prototypes.lua New file
0,0 → 1,267
-- Widget created by Yssaril
--[===[@debug@
local DataVersion = 9001 -- dev version always overwrites everything else :)
--@end-debug@]===]
--@non-debug@
local DataVersion = 37
--@end-non-debug@
local AGSMW = LibStub:NewLibrary("AceGUISharedMediaWidgets-1.0", DataVersion)
 
if not AGSMW then
return -- already loaded and no upgrade necessary
end
 
LoadAddOn("LibSharedMedia-3.0")
local AceGUI = LibStub("AceGUI-3.0")
local Media = LibStub("LibSharedMedia-3.0")
 
AGSMW = AGSMW or {}
 
AceGUIWidgetLSMlists = {
['font'] = Media:HashTable("font"),
['sound'] = Media:HashTable("sound"),
['statusbar'] = Media:HashTable("statusbar"),
['border'] = Media:HashTable("border"),
['background'] = Media:HashTable("background"),
}
 
do
local function disable(frame)
frame.label:SetTextColor(.5,.5,.5)
frame.text:SetTextColor(.5,.5,.5)
frame.dropButton:Disable()
if frame.displayButtonFont then
frame.displayButtonFont:SetTextColor(.5,.5,.5)
frame.displayButton:Disable()
end
end
 
local function enable(frame)
frame.label:SetTextColor(1,.82,0)
frame.text:SetTextColor(1,1,1)
frame.dropButton:Enable()
if frame.displayButtonFont then
frame.displayButtonFont:SetTextColor(1,1,1)
frame.displayButton:Enable()
end
end
 
local displayButtonBackdrop = {
edgeFile = "Interface/Tooltips/UI-Tooltip-Border",
tile = true, tileSize = 16, edgeSize = 16,
insets = { left = 4, right = 4, top = 4, bottom = 4 },
}
 
-- create or retrieve BaseFrame
function AGSMW:GetBaseFrame()
local frame = CreateFrame("Frame", nil, UIParent)
frame:SetHeight(44)
frame:SetWidth(200)
frame:SetPoint("CENTER", UIParent, "CENTER")
 
local label = frame:CreateFontString(nil,"OVERLAY","GameFontNormalSmall")
label:SetPoint("TOPLEFT",frame,"TOPLEFT",0,0)
label:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,0)
label:SetJustifyH("LEFT")
label:SetHeight(18)
label:SetText("")
frame.label = label
 
local DLeft = frame:CreateTexture(nil, "ARTWORK")
DLeft:SetWidth(25)
DLeft:SetHeight(64)
DLeft:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT", -17, -21)
DLeft:SetTexture([[Interface\Glues\CharacterCreate\CharacterCreate-LabelFrame]])
DLeft:SetTexCoord(0, 0.1953125, 0, 1)
frame.DLeft = DLeft
local DRight = frame:CreateTexture(nil, "ARTWORK")
DRight:SetWidth(25)
DRight:SetHeight(64)
DRight:SetPoint("TOP", DLeft, "TOP")
DRight:SetPoint("RIGHT", frame, "RIGHT", 17, 0)
DRight:SetTexture([[Interface\Glues\CharacterCreate\CharacterCreate-LabelFrame]])
DRight:SetTexCoord(0.8046875, 1, 0, 1)
frame.DRight = DRight
local DMiddle = frame:CreateTexture(nil, "ARTWORK")
DMiddle:SetHeight(64)
DMiddle:SetPoint("TOP", DLeft, "TOP")
DMiddle:SetPoint("LEFT", DLeft, "RIGHT")
DMiddle:SetPoint("RIGHT", DRight, "LEFT")
DMiddle:SetTexture([[Interface\Glues\CharacterCreate\CharacterCreate-LabelFrame]])
DMiddle:SetTexCoord(0.1953125, 0.8046875, 0, 1)
frame.DMiddle = DMiddle
 
local text = frame:CreateFontString(nil,"OVERLAY","GameFontHighlightSmall")
text:SetPoint("RIGHT",DRight,"RIGHT",-43,1)
text:SetPoint("LEFT",DLeft,"LEFT",26,1)
text:SetJustifyH("RIGHT")
text:SetHeight(18)
text:SetText("")
frame.text = text
 
local dropButton = CreateFrame("Button", nil, frame)
dropButton:SetWidth(24)
dropButton:SetHeight(24)
dropButton:SetPoint("TOPRIGHT", DRight, "TOPRIGHT", -16, -18)
dropButton:SetNormalTexture([[Interface\ChatFrame\UI-ChatIcon-ScrollDown-Up]])
dropButton:SetPushedTexture([[Interface\ChatFrame\UI-ChatIcon-ScrollDown-Down]])
dropButton:SetDisabledTexture([[Interface\ChatFrame\UI-ChatIcon-ScrollDown-Disabled]])
dropButton:SetHighlightTexture([[Interface\Buttons\UI-Common-MouseHilight]], "ADD")
frame.dropButton = dropButton
 
frame.Disable = disable
frame.Enable = enable
return frame
end
 
function AGSMW:GetBaseFrameWithWindow()
local frame = self:GetBaseFrame()
 
local displayButton = CreateFrame("Button", nil, frame)
displayButton:SetHeight(42)
displayButton:SetWidth(42)
displayButton:SetPoint("TOPLEFT", frame, "TOPLEFT", 1, -2)
displayButton:SetBackdrop(displayButtonBackdrop)
displayButton:SetBackdropBorderColor(.5, .5, .5)
frame.displayButton = displayButton
 
frame.label:SetPoint("TOPLEFT",displayButton,"TOPRIGHT",1,2)
 
frame.DLeft:SetPoint("BOTTOMLEFT", displayButton, "BOTTOMRIGHT", -17, -20)
 
return frame
end
 
end
 
do
 
local sliderBackdrop = {
["bgFile"] = [[Interface\Buttons\UI-SliderBar-Background]],
["edgeFile"] = [[Interface\Buttons\UI-SliderBar-Border]],
["tile"] = true,
["edgeSize"] = 8,
["tileSize"] = 8,
["insets"] = {
["left"] = 3,
["right"] = 3,
["top"] = 3,
["bottom"] = 3,
},
}
local frameBackdrop = {
bgFile=[[Interface\DialogFrame\UI-DialogBox-Background-Dark]],
edgeFile = [[Interface\DialogFrame\UI-DialogBox-Border]],
tile = true, tileSize = 32, edgeSize = 32,
insets = { left = 11, right = 12, top = 12, bottom = 9 },
}
 
local function OnMouseWheel(self, dir)
self.slider:SetValue(self.slider:GetValue()+(15*dir*-1))
end
 
local function AddFrame(self, frame)
frame:SetParent(self.contentframe)
local strata = self:GetFrameStrata()
frame:SetFrameStrata(strata)
local level = self:GetFrameLevel() + 100
frame:SetFrameLevel(level)
if next(self.contentRepo) then
frame:SetPoint("TOPLEFT", self.contentRepo[#self.contentRepo], "BOTTOMLEFT", 0, 0)
frame:SetPoint("RIGHT", self.contentframe, "RIGHT", 0, 0)
self.contentframe:SetHeight(self.contentframe:GetHeight() + frame:GetHeight())
self.contentRepo[#self.contentRepo+1] = frame
else
self.contentframe:SetHeight(frame:GetHeight())
frame:SetPoint("TOPLEFT", self.contentframe, "TOPLEFT", 0, 0)
frame:SetPoint("RIGHT", self.contentframe, "RIGHT", 0, 0)
self.contentRepo[1] = frame
end
if self.contentframe:GetHeight() > UIParent:GetHeight()*2/5 - 20 then
self.scrollframe:SetWidth(146)
self:SetHeight(UIParent:GetHeight()*2/5)
self.slider:Show()
self:SetScript("OnMouseWheel", OnMouseWheel)
self.scrollframe:UpdateScrollChildRect()
self.slider:SetMinMaxValues(0, self.contentframe:GetHeight()-self.scrollframe:GetHeight())
else
self.scrollframe:SetWidth(160)
self:SetHeight(self.contentframe:GetHeight()+25)
self.slider:Hide()
self:SetScript("OnMouseWheel", nil)
self.scrollframe:UpdateScrollChildRect()
self.slider:SetMinMaxValues(0, 0)
end
self.contentframe:SetWidth(self.scrollframe:GetWidth())
end
 
local function ClearFrames(self)
for i, frame in ipairs(self.contentRepo) do
frame:ReturnSelf()
self.contentRepo[i] = nil
end
end
 
local function slider_OnValueChanged(self, value)
self.frame.scrollframe:SetVerticalScroll(value)
end
 
local DropDownCache = {}
function AGSMW:GetDropDownFrame()
local frame
if next(DropDownCache) then
frame = table.remove(DropDownCache)
else
frame = CreateFrame("Frame", nil, UIParent)
frame:SetClampedToScreen(true)
frame:SetWidth(188)
frame:SetBackdrop(frameBackdrop)
frame:SetFrameStrata("TOOLTIP")
frame:EnableMouseWheel(true)
 
local contentframe = CreateFrame("Frame", nil, frame)
contentframe:SetWidth(160)
contentframe:SetHeight(0)
frame.contentframe = contentframe
local scrollframe = CreateFrame("ScrollFrame", nil, frame)
scrollframe:SetPoint("TOPLEFT", frame, "TOPLEFT", 14, -13)
scrollframe:SetPoint("BOTTOM", frame, "BOTTOM", 0, 12)
scrollframe:SetWidth(160)
scrollframe:SetScrollChild(contentframe)
frame.scrollframe = scrollframe
local bgTex = frame:CreateTexture(nil, "ARTWORK")
bgTex:SetAllPoints(scrollframe)
frame.bgTex = bgTex
 
frame.AddFrame = AddFrame
frame.ClearFrames = ClearFrames
frame.contentRepo = {} -- store all our frames in here so we can get rid of them later
local slider = CreateFrame("Slider", nil, scrollframe)
slider:SetOrientation("VERTICAL")
slider:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -14, -10)
slider:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -14, 10)
slider:SetBackdrop(sliderBackdrop)
slider:SetThumbTexture([[Interface\Buttons\UI-SliderBar-Button-Vertical]])
slider:SetMinMaxValues(0, 1)
--slider:SetValueStep(1)
slider:SetWidth(12)
slider.frame = frame
slider:SetScript("OnValueChanged", slider_OnValueChanged)
frame.slider = slider
end
frame:SetHeight(UIParent:GetHeight()*2/5)
frame.slider:SetValue(0)
frame:Show()
return frame
end
 
function AGSMW:ReturnDropDownFrame(frame)
ClearFrames(frame)
frame:ClearAllPoints()
frame:Hide()
frame:SetBackdrop(frameBackdrop)
frame.bgTex:SetTexture(nil)
table.insert(DropDownCache, frame)
return nil
end
end
mNameplates/Libs/AceGUI-3.0-SharedMediaWidgets/FontWidget.lua New file
0,0 → 1,214
-- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0
-- Widget created by Yssaril
 
local AceGUI = LibStub("AceGUI-3.0")
local Media = LibStub("LibSharedMedia-3.0")
 
local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0")
 
do
local widgetType = "LSM30_Font"
local widgetVersion = 9
 
local contentFrameCache = {}
local function ReturnSelf(self)
self:ClearAllPoints()
self:Hide()
self.check:Hide()
table.insert(contentFrameCache, self)
end
 
local function ContentOnClick(this, button)
local self = this.obj
self:Fire("OnValueChanged", this.text:GetText())
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function GetContentLine()
local frame
if next(contentFrameCache) then
frame = table.remove(contentFrameCache)
else
frame = CreateFrame("Button", nil, UIParent)
--frame:SetWidth(200)
frame:SetHeight(18)
frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD")
frame:SetScript("OnClick", ContentOnClick)
local check = frame:CreateTexture("OVERLAY")
check:SetWidth(16)
check:SetHeight(16)
check:SetPoint("LEFT",frame,"LEFT",1,-1)
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check")
check:Hide()
frame.check = check
local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite")
text:SetPoint("LEFT", check, "RIGHT", 1, 0)
text:SetPoint("RIGHT", frame, "RIGHT", -2, 0)
text:SetJustifyH("LEFT")
text:SetText("Test Test Test Test Test Test Test")
frame.text = text
frame.ReturnSelf = ReturnSelf
end
frame:Show()
return frame
end
 
local function OnAcquire(self)
self:SetHeight(44)
self:SetWidth(200)
end
 
local function OnRelease(self)
self:SetText("")
self:SetLabel("")
self:SetDisabled(false)
 
self.value = nil
self.list = nil
self.open = nil
self.hasClose = nil
 
self.frame:ClearAllPoints()
self.frame:Hide()
end
 
local function SetValue(self, value) -- Set the value to an item in the List.
if self.list then
self:SetText(value or "")
end
self.value = value
end
 
local function GetValue(self)
return self.value
end
 
local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs)
self.list = list or Media:HashTable("font")
end
 
local function SetText(self, text) -- Set the text displayed in the box.
self.frame.text:SetText(text or "")
local font = self.list[text] ~= text and self.list[text] or Media:Fetch('font',text)
local _, size, outline= self.frame.text:GetFont()
self.frame.text:SetFont(font,size,outline)
end
 
local function SetLabel(self, text) -- Set the text for the label.
self.frame.label:SetText(text or "")
end
 
local function AddItem(self, key, value) -- Add an item to the list.
self.list = self.list or {}
self.list[key] = value
end
local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>>
 
local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>>
local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>>
local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>>
 
local function SetDisabled(self, disabled) -- Disable the widget.
self.disabled = disabled
if disabled then
self.frame:Disable()
else
self.frame:Enable()
end
end
 
local function textSort(a,b)
return string.upper(a) < string.upper(b)
end
 
local sortedlist = {}
local function ToggleDrop(this)
local self = this.obj
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
AceGUI:ClearFocus()
else
AceGUI:SetFocus(self)
self.dropdown = AGSMW:GetDropDownFrame()
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT")
for k, v in pairs(self.list) do
sortedlist[#sortedlist+1] = k
end
table.sort(sortedlist, textSort)
for i, k in ipairs(sortedlist) do
local f = GetContentLine()
local _, size, outline= f.text:GetFont()
local font = self.list[k] ~= k and self.list[k] or Media:Fetch('font',k)
f.text:SetFont(font,size,outline)
f.text:SetText(k)
if k == self.value then
f.check:Show()
end
f.obj = self
self.dropdown:AddFrame(f)
end
wipe(sortedlist)
end
end
 
local function ClearFocus(self)
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function OnHide(this)
local self = this.obj
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function Drop_OnEnter(this)
this.obj:Fire("OnEnter")
end
 
local function Drop_OnLeave(this)
this.obj:Fire("OnLeave")
end
 
local function Constructor()
local frame = AGSMW:GetBaseFrame()
local self = {}
 
self.type = widgetType
self.frame = frame
frame.obj = self
frame.dropButton.obj = self
frame.dropButton:SetScript("OnEnter", Drop_OnEnter)
frame.dropButton:SetScript("OnLeave", Drop_OnLeave)
frame.dropButton:SetScript("OnClick",ToggleDrop)
frame:SetScript("OnHide", OnHide)
 
self.alignoffset = 31
 
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
self.ClearFocus = ClearFocus
self.SetText = SetText
self.SetValue = SetValue
self.GetValue = GetValue
self.SetList = SetList
self.SetLabel = SetLabel
self.SetDisabled = SetDisabled
self.AddItem = AddItem
self.SetMultiselect = SetMultiselect
self.GetMultiselect = GetMultiselect
self.SetItemValue = SetItemValue
self.SetItemDisabled = SetItemDisabled
self.ToggleDrop = ToggleDrop
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion)
 
end
mNameplates/Libs/AceGUI-3.0-SharedMediaWidgets/SoundWidget.lua New file
0,0 → 1,262
-- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0
-- Widget created by Yssaril
 
local AceGUI = LibStub("AceGUI-3.0")
local Media = LibStub("LibSharedMedia-3.0")
 
local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0")
 
do
local widgetType = "LSM30_Sound"
local widgetVersion = 9
 
local contentFrameCache = {}
local function ReturnSelf(self)
self:ClearAllPoints()
self:Hide()
self.check:Hide()
table.insert(contentFrameCache, self)
end
 
local function ContentOnClick(this, button)
local self = this.obj
self:Fire("OnValueChanged", this.text:GetText())
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function ContentSpeakerOnClick(this, button)
local self = this.frame.obj
local sound = this.frame.text:GetText()
PlaySoundFile(self.list[sound] ~= sound and self.list[sound] or Media:Fetch('sound',sound))
end
 
local function GetContentLine()
local frame
if next(contentFrameCache) then
frame = table.remove(contentFrameCache)
else
frame = CreateFrame("Button", nil, UIParent)
--frame:SetWidth(200)
frame:SetHeight(18)
frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD")
frame:SetScript("OnClick", ContentOnClick)
local check = frame:CreateTexture("OVERLAY")
check:SetWidth(16)
check:SetHeight(16)
check:SetPoint("LEFT",frame,"LEFT",1,-1)
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check")
check:Hide()
frame.check = check
 
local soundbutton = CreateFrame("Button", nil, frame)
soundbutton:SetWidth(16)
soundbutton:SetHeight(16)
soundbutton:SetPoint("RIGHT",frame,"RIGHT",-1,0)
soundbutton.frame = frame
soundbutton:SetScript("OnClick", ContentSpeakerOnClick)
frame.soundbutton = soundbutton
 
local speaker = soundbutton:CreateTexture(nil, "BACKGROUND")
speaker:SetTexture("Interface\\Common\\VoiceChat-Speaker")
speaker:SetAllPoints(soundbutton)
frame.speaker = speaker
local speakeron = soundbutton:CreateTexture(nil, "HIGHLIGHT")
speakeron:SetTexture("Interface\\Common\\VoiceChat-On")
speakeron:SetAllPoints(soundbutton)
frame.speakeron = speakeron
 
local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite")
text:SetPoint("LEFT", check, "RIGHT", 1, 0)
text:SetPoint("RIGHT", soundbutton, "LEFT", -2, 0)
text:SetJustifyH("LEFT")
text:SetText("Test Test Test Test Test Test Test")
frame.text = text
frame.ReturnSelf = ReturnSelf
end
frame:Show()
return frame
end
 
local function OnAcquire(self)
self:SetHeight(44)
self:SetWidth(200)
end
 
local function OnRelease(self)
self:SetText("")
self:SetLabel("")
self:SetDisabled(false)
 
self.value = nil
self.list = nil
self.open = nil
self.hasClose = nil
 
self.frame:ClearAllPoints()
self.frame:Hide()
end
 
local function SetValue(self, value) -- Set the value to an item in the List.
if self.list then
self:SetText(value or "")
end
self.value = value
end
 
local function GetValue(self)
return self.value
end
 
local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs)
self.list = list or Media:HashTable("sound")
end
 
local function SetText(self, text) -- Set the text displayed in the box.
self.frame.text:SetText(text or "")
end
 
local function SetLabel(self, text) -- Set the text for the label.
self.frame.label:SetText(text or "")
end
 
local function AddItem(self, key, value) -- Add an item to the list.
self.list = self.list or {}
self.list[key] = value
end
local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>>
 
local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>>
local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>>
local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>>
 
local function SetDisabled(self, disabled) -- Disable the widget.
self.disabled = disabled
if disabled then
self.frame:Disable()
self.speaker:SetDesaturated(true)
self.speakeron:SetDesaturated(true)
else
self.frame:Enable()
self.speaker:SetDesaturated(false)
self.speakeron:SetDesaturated(false)
end
end
 
local function textSort(a,b)
return string.upper(a) < string.upper(b)
end
 
local sortedlist = {}
local function ToggleDrop(this)
local self = this.obj
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
AceGUI:ClearFocus()
else
AceGUI:SetFocus(self)
self.dropdown = AGSMW:GetDropDownFrame()
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT")
for k, v in pairs(self.list) do
sortedlist[#sortedlist+1] = k
end
table.sort(sortedlist, textSort)
for i, k in ipairs(sortedlist) do
local f = GetContentLine()
f.text:SetText(k)
if k == self.value then
f.check:Show()
end
f.obj = self
self.dropdown:AddFrame(f)
end
wipe(sortedlist)
end
end
 
local function ClearFocus(self)
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function OnHide(this)
local self = this.obj
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function Drop_OnEnter(this)
this.obj:Fire("OnEnter")
end
 
local function Drop_OnLeave(this)
this.obj:Fire("OnLeave")
end
 
local function WidgetPlaySound(this)
local self = this.obj
local sound = self.frame.text:GetText()
PlaySoundFile(self.list[sound] ~= sound and self.list[sound] or Media:Fetch('sound',sound))
end
 
local function Constructor()
local frame = AGSMW:GetBaseFrame()
local self = {}
 
self.type = widgetType
self.frame = frame
frame.obj = self
frame.dropButton.obj = self
frame.dropButton:SetScript("OnEnter", Drop_OnEnter)
frame.dropButton:SetScript("OnLeave", Drop_OnLeave)
frame.dropButton:SetScript("OnClick",ToggleDrop)
frame:SetScript("OnHide", OnHide)
 
 
local soundbutton = CreateFrame("Button", nil, frame)
soundbutton:SetWidth(16)
soundbutton:SetHeight(16)
soundbutton:SetPoint("LEFT",frame.DLeft,"LEFT",26,1)
soundbutton:SetScript("OnClick", WidgetPlaySound)
soundbutton.obj = self
self.soundbutton = soundbutton
frame.text:SetPoint("LEFT",soundbutton,"RIGHT",2,0)
 
 
local speaker = soundbutton:CreateTexture(nil, "BACKGROUND")
speaker:SetTexture("Interface\\Common\\VoiceChat-Speaker")
speaker:SetAllPoints(soundbutton)
self.speaker = speaker
local speakeron = soundbutton:CreateTexture(nil, "HIGHLIGHT")
speakeron:SetTexture("Interface\\Common\\VoiceChat-On")
speakeron:SetAllPoints(soundbutton)
self.speakeron = speakeron
 
self.alignoffset = 31
 
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
self.ClearFocus = ClearFocus
self.SetText = SetText
self.SetValue = SetValue
self.GetValue = GetValue
self.SetList = SetList
self.SetLabel = SetLabel
self.SetDisabled = SetDisabled
self.AddItem = AddItem
self.SetMultiselect = SetMultiselect
self.GetMultiselect = GetMultiselect
self.SetItemValue = SetItemValue
self.SetItemDisabled = SetItemDisabled
self.ToggleDrop = ToggleDrop
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion)
 
end
mNameplates/Libs/AceGUI-3.0-SharedMediaWidgets/StatusbarWidget.lua New file
0,0 → 1,230
-- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0
-- Widget created by Yssaril
 
local AceGUI = LibStub("AceGUI-3.0")
local Media = LibStub("LibSharedMedia-3.0")
 
local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0")
 
do
local widgetType = "LSM30_Statusbar"
local widgetVersion = 9
 
local contentFrameCache = {}
local function ReturnSelf(self)
self:ClearAllPoints()
self:Hide()
self.check:Hide()
table.insert(contentFrameCache, self)
end
 
local function ContentOnClick(this, button)
local self = this.obj
self:Fire("OnValueChanged", this.text:GetText())
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function GetContentLine()
local frame
if next(contentFrameCache) then
frame = table.remove(contentFrameCache)
else
frame = CreateFrame("Button", nil, UIParent)
--frame:SetWidth(200)
frame:SetHeight(18)
frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD")
frame:SetScript("OnClick", ContentOnClick)
local check = frame:CreateTexture("OVERLAY")
check:SetWidth(16)
check:SetHeight(16)
check:SetPoint("LEFT",frame,"LEFT",1,-1)
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check")
check:Hide()
frame.check = check
local bar = frame:CreateTexture("ARTWORK")
bar:SetHeight(16)
bar:SetPoint("LEFT",check,"RIGHT",1,0)
bar:SetPoint("RIGHT",frame,"RIGHT",-1,0)
frame.bar = bar
local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite")
 
local font, size = text:GetFont()
text:SetFont(font,size,"OUTLINE")
 
text:SetPoint("LEFT", check, "RIGHT", 3, 0)
text:SetPoint("RIGHT", frame, "RIGHT", -2, 0)
text:SetJustifyH("LEFT")
text:SetText("Test Test Test Test Test Test Test")
frame.text = text
frame.ReturnSelf = ReturnSelf
end
frame:Show()
return frame
end
 
local function OnAcquire(self)
self:SetHeight(44)
self:SetWidth(200)
end
 
local function OnRelease(self)
self:SetText("")
self:SetLabel("")
self:SetDisabled(false)
 
self.value = nil
self.list = nil
self.open = nil
self.hasClose = nil
 
self.frame:ClearAllPoints()
self.frame:Hide()
end
 
local function SetValue(self, value) -- Set the value to an item in the List.
if self.list then
self:SetText(value or "")
end
self.value = value
end
 
local function GetValue(self)
return self.value
end
 
local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs)
self.list = list or Media:HashTable("statusbar")
end
 
 
local function SetText(self, text) -- Set the text displayed in the box.
self.frame.text:SetText(text or "")
local statusbar = self.list[text] ~= text and self.list[text] or Media:Fetch('statusbar',text)
self.bar:SetTexture(statusbar)
end
 
local function SetLabel(self, text) -- Set the text for the label.
self.frame.label:SetText(text or "")
end
 
local function AddItem(self, key, value) -- Add an item to the list.
self.list = self.list or {}
self.list[key] = value
end
local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>>
 
local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>>
local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>>
local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>>
 
local function SetDisabled(self, disabled) -- Disable the widget.
self.disabled = disabled
if disabled then
self.frame:Disable()
else
self.frame:Enable()
end
end
 
local function textSort(a,b)
return string.upper(a) < string.upper(b)
end
 
local sortedlist = {}
local function ToggleDrop(this)
local self = this.obj
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
AceGUI:ClearFocus()
else
AceGUI:SetFocus(self)
self.dropdown = AGSMW:GetDropDownFrame()
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT")
for k, v in pairs(self.list) do
sortedlist[#sortedlist+1] = k
end
table.sort(sortedlist, textSort)
for i, k in ipairs(sortedlist) do
local f = GetContentLine()
f.text:SetText(k)
--print(k)
if k == self.value then
f.check:Show()
end
 
local statusbar = self.list[k] ~= k and self.list[k] or Media:Fetch('statusbar',k)
f.bar:SetTexture(statusbar)
f.obj = self
f.dropdown = self.dropdown
self.dropdown:AddFrame(f)
end
wipe(sortedlist)
end
end
 
local function ClearFocus(self)
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function OnHide(this)
local self = this.obj
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function Drop_OnEnter(this)
this.obj:Fire("OnEnter")
end
 
local function Drop_OnLeave(this)
this.obj:Fire("OnLeave")
end
 
local function Constructor()
local frame = AGSMW:GetBaseFrame()
local self = {}
 
self.type = widgetType
self.frame = frame
frame.obj = self
frame.dropButton.obj = self
frame.dropButton:SetScript("OnEnter", Drop_OnEnter)
frame.dropButton:SetScript("OnLeave", Drop_OnLeave)
frame.dropButton:SetScript("OnClick",ToggleDrop)
frame:SetScript("OnHide", OnHide)
 
local bar = frame:CreateTexture(nil, "ARTWORK")
bar:SetPoint("TOPLEFT", frame,"TOPLEFT",6,-25)
bar:SetPoint("BOTTOMRIGHT", frame,"BOTTOMRIGHT", -21, 5)
self.bar = bar
 
self.alignoffset = 31
 
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
self.ClearFocus = ClearFocus
self.SetText = SetText
self.SetValue = SetValue
self.GetValue = GetValue
self.SetList = SetList
self.SetLabel = SetLabel
self.SetDisabled = SetDisabled
self.AddItem = AddItem
self.SetMultiselect = SetMultiselect
self.GetMultiselect = GetMultiselect
self.SetItemValue = SetItemValue
self.SetItemDisabled = SetItemDisabled
self.ToggleDrop = ToggleDrop
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion)
 
end
mNameplates/Libs/AceGUI-3.0-SharedMediaWidgets/BorderWidget.lua New file
0,0 → 1,228
-- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0
-- Widget created by Yssaril
 
local AceGUI = LibStub("AceGUI-3.0")
local Media = LibStub("LibSharedMedia-3.0")
 
local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0")
 
do
local widgetType = "LSM30_Border"
local widgetVersion = 9
 
local contentFrameCache = {}
local function ReturnSelf(self)
self:ClearAllPoints()
self:Hide()
self.check:Hide()
table.insert(contentFrameCache, self)
end
 
local function ContentOnClick(this, button)
local self = this.obj
self:Fire("OnValueChanged", this.text:GetText())
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function ContentOnEnter(this, button)
local self = this.obj
local text = this.text:GetText()
local border = self.list[text] ~= text and self.list[text] or Media:Fetch('border',text)
this.dropdown:SetBackdrop({edgeFile = border,
bgFile=[[Interface\DialogFrame\UI-DialogBox-Background-Dark]],
tile = true, tileSize = 16, edgeSize = 16,
insets = { left = 4, right = 4, top = 4, bottom = 4 }})
end
 
local function GetContentLine()
local frame
if next(contentFrameCache) then
frame = table.remove(contentFrameCache)
else
frame = CreateFrame("Button", nil, UIParent)
--frame:SetWidth(200)
frame:SetHeight(18)
frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD")
frame:SetScript("OnClick", ContentOnClick)
frame:SetScript("OnEnter", ContentOnEnter)
local check = frame:CreateTexture("OVERLAY")
check:SetWidth(16)
check:SetHeight(16)
check:SetPoint("LEFT",frame,"LEFT",1,-1)
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check")
check:Hide()
frame.check = check
local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite")
text:SetPoint("LEFT", check, "RIGHT", 1, 0)
text:SetPoint("RIGHT", frame, "RIGHT", -2, 0)
text:SetJustifyH("LEFT")
text:SetText("Test Test Test Test Test Test Test")
frame.text = text
frame.ReturnSelf = ReturnSelf
end
frame:Show()
return frame
end
 
local function OnAcquire(self)
self:SetHeight(44)
self:SetWidth(200)
end
 
local function OnRelease(self)
self:SetText("")
self:SetLabel("")
self:SetDisabled(false)
 
self.value = nil
self.list = nil
self.open = nil
self.hasClose = nil
 
self.frame:ClearAllPoints()
self.frame:Hide()
end
 
local function SetValue(self, value) -- Set the value to an item in the List.
if self.list then
self:SetText(value or "")
end
self.value = value
end
 
local function GetValue(self)
return self.value
end
 
local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs)
self.list = list or Media:HashTable("border")
end
 
 
local function SetText(self, text) -- Set the text displayed in the box.
self.frame.text:SetText(text or "")
local border = self.list[text] ~= text and self.list[text] or Media:Fetch('border',text)
 
self.frame.displayButton:SetBackdrop({edgeFile = border,
bgFile=[[Interface\DialogFrame\UI-DialogBox-Background-Dark]],
tile = true, tileSize = 16, edgeSize = 16,
insets = { left = 4, right = 4, top = 4, bottom = 4 }})
end
 
local function SetLabel(self, text) -- Set the text for the label.
self.frame.label:SetText(text or "")
end
 
local function AddItem(self, key, value) -- Add an item to the list.
self.list = self.list or {}
self.list[key] = value
end
local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>>
 
local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>>
local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>>
local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>>
 
local function SetDisabled(self, disabled) -- Disable the widget.
self.disabled = disabled
if disabled then
self.frame:Disable()
else
self.frame:Enable()
end
end
 
local function textSort(a,b)
return string.upper(a) < string.upper(b)
end
 
local sortedlist = {}
local function ToggleDrop(this)
local self = this.obj
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
AceGUI:ClearFocus()
else
AceGUI:SetFocus(self)
self.dropdown = AGSMW:GetDropDownFrame()
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT")
for k, v in pairs(self.list) do
sortedlist[#sortedlist+1] = k
end
table.sort(sortedlist, textSort)
for i, k in ipairs(sortedlist) do
local f = GetContentLine()
f.text:SetText(k)
--print(k)
if k == self.value then
f.check:Show()
end
f.obj = self
f.dropdown = self.dropdown
self.dropdown:AddFrame(f)
end
wipe(sortedlist)
end
end
 
local function ClearFocus(self)
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function OnHide(this)
local self = this.obj
if self.dropdown then
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown)
end
end
 
local function Drop_OnEnter(this)
this.obj:Fire("OnEnter")
end
 
local function Drop_OnLeave(this)
this.obj:Fire("OnLeave")
end
 
local function Constructor()
local frame = AGSMW:GetBaseFrameWithWindow()
local self = {}
 
self.type = widgetType
self.frame = frame
frame.obj = self
frame.dropButton.obj = self
frame.dropButton:SetScript("OnEnter", Drop_OnEnter)
frame.dropButton:SetScript("OnLeave", Drop_OnLeave)
frame.dropButton:SetScript("OnClick",ToggleDrop)
frame:SetScript("OnHide", OnHide)
 
self.alignoffset = 31
 
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
self.ClearFocus = ClearFocus
self.SetText = SetText
self.SetValue = SetValue
self.GetValue = GetValue
self.SetList = SetList
self.SetLabel = SetLabel
self.SetDisabled = SetDisabled
self.AddItem = AddItem
self.SetMultiselect = SetMultiselect
self.GetMultiselect = GetMultiselect
self.SetItemValue = SetItemValue
self.SetItemDisabled = SetItemDisabled
self.ToggleDrop = ToggleDrop
 
AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion)
 
end
mNameplates/Libs/CallbackHandler-1.0/CallbackHandler-1.0.xml New file
0,0 → 1,4
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Script file="CallbackHandler-1.0.lua"/>
</Ui>
\ No newline at end of file
mNameplates/Libs/CallbackHandler-1.0/CallbackHandler-1.0.lua New file
0,0 → 1,239
--[[ $Id: CallbackHandler-1.0.lua 3 2008-09-29 16:54:20Z nevcairiel $ ]]
local MAJOR, MINOR = "CallbackHandler-1.0", 3
local CallbackHandler = LibStub:NewLibrary(MAJOR, MINOR)
 
if not CallbackHandler then return end -- No upgrade needed
 
local meta = {__index = function(tbl, key) tbl[key] = {} return tbl[key] end}
 
local type = type
local pcall = pcall
local pairs = pairs
local assert = assert
local concat = table.concat
local loadstring = loadstring
local next = next
local select = select
local type = type
local xpcall = xpcall
 
local function errorhandler(err)
return geterrorhandler()(err)
end
 
local function CreateDispatcher(argCount)
local code = [[
local next, xpcall, eh = ...
 
local method, ARGS
local function call() method(ARGS) end
 
local function dispatch(handlers, ...)
local index
index, method = next(handlers)
if not method then return end
local OLD_ARGS = ARGS
ARGS = ...
repeat
xpcall(call, eh)
index, method = next(handlers, index)
until not method
ARGS = OLD_ARGS
end
 
return dispatch
]]
 
local ARGS, OLD_ARGS = {}, {}
for i = 1, argCount do ARGS[i], OLD_ARGS[i] = "arg"..i, "old_arg"..i end
code = code:gsub("OLD_ARGS", concat(OLD_ARGS, ", ")):gsub("ARGS", concat(ARGS, ", "))
return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(next, xpcall, errorhandler)
end
 
local Dispatchers = setmetatable({}, {__index=function(self, argCount)
local dispatcher = CreateDispatcher(argCount)
rawset(self, argCount, dispatcher)
return dispatcher
end})
 
--------------------------------------------------------------------------
-- CallbackHandler:New
--
-- target - target object to embed public APIs in
-- RegisterName - name of the callback registration API, default "RegisterCallback"
-- UnregisterName - name of the callback unregistration API, default "UnregisterCallback"
-- UnregisterAllName - name of the API to unregister all callbacks, default "UnregisterAllCallbacks". false == don't publish this API.
 
function CallbackHandler:New(target, RegisterName, UnregisterName, UnregisterAllName, OnUsed, OnUnused)
-- TODO: Remove this after beta has gone out
assert(not OnUsed and not OnUnused, "ACE-80: OnUsed/OnUnused are deprecated. Callbacks are now done to registry.OnUsed and registry.OnUnused")
 
RegisterName = RegisterName or "RegisterCallback"
UnregisterName = UnregisterName or "UnregisterCallback"
if UnregisterAllName==nil then -- false is used to indicate "don't want this method"
UnregisterAllName = "UnregisterAllCallbacks"
end
 
-- we declare all objects and exported APIs inside this closure to quickly gain access
-- to e.g. function names, the "target" parameter, etc
 
 
-- Create the registry object
local events = setmetatable({}, meta)
local registry = { recurse=0, events=events }
 
-- registry:Fire() - fires the given event/message into the registry
function registry:Fire(eventname, ...)
if not rawget(events, eventname) or not next(events[eventname]) then return end
local oldrecurse = registry.recurse
registry.recurse = oldrecurse + 1
 
Dispatchers[select('#', ...) + 1](events[eventname], eventname, ...)
 
registry.recurse = oldrecurse
 
if registry.insertQueue and oldrecurse==0 then
-- Something in one of our callbacks wanted to register more callbacks; they got queued
for eventname,callbacks in pairs(registry.insertQueue) do
local first = not rawget(events, eventname) or not next(events[eventname]) -- test for empty before. not test for one member after. that one member may have been overwritten.
for self,func in pairs(callbacks) do
events[eventname][self] = func
-- fire OnUsed callback?
if first and registry.OnUsed then
registry.OnUsed(registry, target, eventname)
first = nil
end
end
end
registry.insertQueue = nil
end
end
 
-- Registration of a callback, handles:
-- self["method"], leads to self["method"](self, ...)
-- self with function ref, leads to functionref(...)
-- "addonId" (instead of self) with function ref, leads to functionref(...)
-- all with an optional arg, which, if present, gets passed as first argument (after self if present)
target[RegisterName] = function(self, eventname, method, ... --[[actually just a single arg]])
if type(eventname) ~= "string" then
error("Usage: "..RegisterName.."(eventname, method[, arg]): 'eventname' - string expected.", 2)
end
 
method = method or eventname
 
local first = not rawget(events, eventname) or not next(events[eventname]) -- test for empty before. not test for one member after. that one member may have been overwritten.
 
if type(method) ~= "string" and type(method) ~= "function" then
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - string or function expected.", 2)
end
 
local regfunc
 
if type(method) == "string" then
-- self["method"] calling style
if type(self) ~= "table" then
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): self was not a table?", 2)
elseif self==target then
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): do not use Library:"..RegisterName.."(), use your own 'self'", 2)
elseif type(self[method]) ~= "function" then
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - method '"..tostring(method).."' not found on self.", 2)
end
 
if select("#",...)>=1 then -- this is not the same as testing for arg==nil!
local arg=select(1,...)
regfunc = function(...) self[method](self,arg,...) end
else
regfunc = function(...) self[method](self,...) end
end
else
-- function ref with self=object or self="addonId"
if type(self)~="table" and type(self)~="string" then
error("Usage: "..RegisterName.."(self or \"addonId\", eventname, method): 'self or addonId': table or string expected.", 2)
end
 
if select("#",...)>=1 then -- this is not the same as testing for arg==nil!
local arg=select(1,...)
regfunc = function(...) method(arg,...) end
else
regfunc = method
end
end
 
 
if events[eventname][self] or registry.recurse<1 then
-- if registry.recurse<1 then
-- we're overwriting an existing entry, or not currently recursing. just set it.
events[eventname][self] = regfunc
-- fire OnUsed callback?
if registry.OnUsed and first then
registry.OnUsed(registry, target, eventname)
end
else
-- we're currently processing a callback in this registry, so delay the registration of this new entry!
-- yes, we're a bit wasteful on garbage, but this is a fringe case, so we're picking low implementation overhead over garbage efficiency
registry.insertQueue = registry.insertQueue or setmetatable({},meta)
registry.insertQueue[eventname][self] = regfunc
end
end
 
-- Unregister a callback
target[UnregisterName] = function(self, eventname)
if not self or self==target then
error("Usage: "..UnregisterName.."(eventname): bad 'self'", 2)
end
if type(eventname) ~= "string" then
error("Usage: "..UnregisterName.."(eventname): 'eventname' - string expected.", 2)
end
if rawget(events, eventname) and events[eventname][self] then
events[eventname][self] = nil
-- Fire OnUnused callback?
if registry.OnUnused and not next(events[eventname]) then
registry.OnUnused(registry, target, eventname)
end
end
if registry.insertQueue and rawget(registry.insertQueue, eventname) and registry.insertQueue[eventname][self] then
registry.insertQueue[eventname][self] = nil
end
end
 
-- OPTIONAL: Unregister all callbacks for given selfs/addonIds
if UnregisterAllName then
target[UnregisterAllName] = function(...)
if select("#",...)<1 then
error("Usage: "..UnregisterAllName.."([whatFor]): missing 'self' or \"addonId\" to unregister events for.", 2)
end
if select("#",...)==1 and ...==target then
error("Usage: "..UnregisterAllName.."([whatFor]): supply a meaningful 'self' or \"addonId\"", 2)
end
 
 
for i=1,select("#",...) do
local self = select(i,...)
if registry.insertQueue then
for eventname, callbacks in pairs(registry.insertQueue) do
if callbacks[self] then
callbacks[self] = nil
end
end
end
for eventname, callbacks in pairs(events) do
if callbacks[self] then
callbacks[self] = nil
-- Fire OnUnused callback?
if registry.OnUnused and not next(callbacks) then
registry.OnUnused(registry, target, eventname)
end
end
end
end
end
end
 
return registry
end
 
 
-- CallbackHandler purposefully does NOT do explicit embedding. Nor does it
-- try to upgrade old implicit embeds since the system is selfcontained and
-- relies on closures to work.
 
mNameplates/Libs/AceHook-3.0/AceHook-3.0.xml New file
0,0 → 1,4
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Script file="AceHook-3.0.lua"/>
</Ui>
\ No newline at end of file
mNameplates/Libs/AceHook-3.0/AceHook-3.0.lua New file
0,0 → 1,514
--- **AceHook-3.0** offers safe Hooking/Unhooking of functions, methods and frame scripts.
-- Using AceHook-3.0 is recommended when you need to unhook your hooks again, so the hook chain isn't broken
-- when you manually restore the original function.
--
-- **AceHook-3.0** can be embeded into your addon, either explicitly by calling AceHook:Embed(MyAddon) or by
-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object
-- and can be accessed directly, without having to explicitly call AceHook itself.\\
-- It is recommended to embed AceHook, otherwise you'll have to specify a custom `self` on all calls you
-- make into AceHook.
-- @class file
-- @name AceHook-3.0
-- @release $Id: AceHook-3.0.lua 877 2009-11-02 15:56:50Z nevcairiel $
local ACEHOOK_MAJOR, ACEHOOK_MINOR = "AceHook-3.0", 5
local AceHook, oldminor = LibStub:NewLibrary(ACEHOOK_MAJOR, ACEHOOK_MINOR)
 
if not AceHook then return end -- No upgrade needed
 
AceHook.embeded = AceHook.embeded or {}
AceHook.registry = AceHook.registry or setmetatable({}, {__index = function(tbl, key) tbl[key] = {} return tbl[key] end })
AceHook.handlers = AceHook.handlers or {}
AceHook.actives = AceHook.actives or {}
AceHook.scripts = AceHook.scripts or {}
AceHook.onceSecure = AceHook.onceSecure or {}
AceHook.hooks = AceHook.hooks or {}
 
-- local upvalues
local registry = AceHook.registry
local handlers = AceHook.handlers
local actives = AceHook.actives
local scripts = AceHook.scripts
local onceSecure = AceHook.onceSecure
 
-- Lua APIs
local pairs, next, type = pairs, next, type
local format = string.format
local assert, error = assert, error
 
-- WoW APIs
local issecurevariable, hooksecurefunc = issecurevariable, hooksecurefunc
local _G = _G
 
-- functions for later definition
local donothing, createHook, hook
 
local protectedScripts = {
OnClick = true,
}
 
-- upgrading of embeded is done at the bottom of the file
 
local mixins = {
"Hook", "SecureHook",
"HookScript", "SecureHookScript",
"Unhook", "UnhookAll",
"IsHooked",
"RawHook", "RawHookScript"
}
 
-- AceHook:Embed( target )
-- target (object) - target object to embed AceHook in
--
-- Embeds AceEevent into the target object making the functions from the mixins list available on target:..
function AceHook:Embed( target )
for k, v in pairs( mixins ) do
target[v] = self[v]
end
self.embeded[target] = true
-- inject the hooks table safely
target.hooks = target.hooks or {}
return target
end
 
-- AceHook:OnEmbedDisable( target )
-- target (object) - target object that is being disabled
--
-- Unhooks all hooks when the target disables.
-- this method should be called by the target manually or by an addon framework
function AceHook:OnEmbedDisable( target )
target:UnhookAll()
end
 
function createHook(self, handler, orig, secure, failsafe)
local uid
local method = type(handler) == "string"
if failsafe and not secure then
-- failsafe hook creation
uid = function(...)
if actives[uid] then
if method then
self[handler](self, ...)
else
handler(...)
end
end
return orig(...)
end
-- /failsafe hook
else
-- all other hooks
uid = function(...)
if actives[uid] then
if method then
return self[handler](self, ...)
else
return handler(...)
end
elseif not secure then -- backup on non secure
return orig(...)
end
end
-- /hook
end
return uid
end
 
function donothing() end
 
function hook(self, obj, method, handler, script, secure, raw, forceSecure, usage)
if not handler then handler = method end
 
-- These asserts make sure AceHooks's devs play by the rules.
assert(not script or type(script) == "boolean")
assert(not secure or type(secure) == "boolean")
assert(not raw or type(raw) == "boolean")
assert(not forceSecure or type(forceSecure) == "boolean")
assert(usage)
 
-- Error checking Battery!
if obj and type(obj) ~= "table" then
error(format("%s: 'object' - nil or table expected got %s", usage, type(obj)), 3)
end
if type(method) ~= "string" then
error(format("%s: 'method' - string expected got %s", usage, type(method)), 3)
end
if type(handler) ~= "string" and type(handler) ~= "function" then
error(format("%s: 'handler' - nil, string, or function expected got %s", usage, type(handler)), 3)
end
if type(handler) == "string" and type(self[handler]) ~= "function" then
error(format("%s: 'handler' - Handler specified does not exist at self[handler]", usage), 3)
end
if script then
if not secure and obj:IsProtected() and protectedScripts[method] then
error(format("Cannot hook secure script %q; Use SecureHookScript(obj, method, [handler]) instead.", method), 3)
end
if not obj or not obj.GetScript or not obj:HasScript(method) then
error(format("%s: You can only hook a script on a frame object", usage), 3)
end
else
local issecure
if obj then
issecure = onceSecure[obj] and onceSecure[obj][method] or issecurevariable(obj, method)
else
issecure = onceSecure[method] or issecurevariable(method)
end
if issecure then
if forceSecure then
if obj then
onceSecure[obj] = onceSecure[obj] or {}
onceSecure[obj][method] = true
else
onceSecure[method] = true
end
elseif not secure then
error(format("%s: Attempt to hook secure function %s. Use `SecureHook' or add `true' to the argument list to override.", usage, method), 3)
end
end
end
 
local uid
if obj then
uid = registry[self][obj] and registry[self][obj][method]
else
uid = registry[self][method]
end
 
if uid then
if actives[uid] then
-- Only two sane choices exist here. We either a) error 100% of the time or b) always unhook and then hook
-- choice b would likely lead to odd debuging conditions or other mysteries so we're going with a.
error(format("Attempting to rehook already active hook %s.", method))
end
 
if handlers[uid] == handler then -- turn on a decative hook, note enclosures break this ability, small memory leak
actives[uid] = true
return
elseif obj then -- is there any reason not to call unhook instead of doing the following several lines?
if self.hooks and self.hooks[obj] then
self.hooks[obj][method] = nil
end
registry[self][obj][method] = nil
else
if self.hooks then
self.hooks[method] = nil
end
registry[self][method] = nil
end
handlers[uid], actives[uid], scripts[uid] = nil, nil, nil
uid = nil
end
 
local orig
if script then
orig = obj:GetScript(method) or donothing
elseif obj then
orig = obj[method]
else
orig = _G[method]
end
 
if not orig then
error(format("%s: Attempting to hook a non existing target", usage), 3)
end
 
uid = createHook(self, handler, orig, secure, not (raw or secure))
 
if obj then
self.hooks[obj] = self.hooks[obj] or {}
registry[self][obj] = registry[self][obj] or {}
registry[self][obj][method] = uid
 
if not secure then
self.hooks[obj][method] = orig
end
 
if script then
-- If the script is empty before, HookScript will not work, so use SetScript instead
-- This will make the hook insecure, but shouldnt matter, since it was empty before.
-- It does not taint the full frame.
if not secure or orig == donothing then
obj:SetScript(method, uid)
elseif secure then
obj:HookScript(method, uid)
end
else
if not secure then
obj[method] = uid
else
hooksecurefunc(obj, method, uid)
end
end
else
registry[self][method] = uid
 
if not secure then
_G[method] = uid
self.hooks[method] = orig
else
hooksecurefunc(method, uid)
end
end
 
actives[uid], handlers[uid], scripts[uid] = true, handler, script and true or nil
end
 
--- Hook a function or a method on an object.
-- The hook created will be a "safe hook", that means that your handler will be called
-- before the hooked function ("Pre-Hook"), and you don't have to call the original function yourself,
-- however you cannot stop the execution of the function, or modify any of the arguments/return values.\\
-- This type of hook is typically used if you need to know if some function got called, and don't want to modify it.
-- @paramsig [object], method, [handler], [hookSecure]
-- @param object The object to hook a method from
-- @param method If object was specified, the name of the method, or the name of the function to hook.
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked function)
-- @param hookSecure If true, AceHook will allow hooking of secure functions.
-- @usage
-- -- create an addon with AceHook embeded
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0")
--
-- function MyAddon:OnEnable()
-- -- Hook ActionButton_UpdateHotkeys, overwriting the secure status
-- self:Hook("ActionButton_UpdateHotkeys", true)
-- end
--
-- function MyAddon:ActionButton_UpdateHotkeys(button, type)
-- print(button:GetName() .. " is updating its HotKey")
-- end
function AceHook:Hook(object, method, handler, hookSecure)
if type(object) == "string" then
method, handler, hookSecure, object = object, method, handler, nil
end
 
if handler == true then
handler, hookSecure = nil, true
end
 
hook(self, object, method, handler, false, false, false, hookSecure or false, "Usage: Hook([object], method, [handler], [hookSecure])")
end
 
--- RawHook a function or a method on an object.
-- The hook created will be a "raw hook", that means that your handler will completly replace
-- the original function, and your handler has to call the original function (or not, depending on your intentions).\\
-- The original function will be stored in `self.hooks[object][method]` or `self.hooks[functionName]` respectively.\\
-- This type of hook can be used for all purposes, and is usually the most common case when you need to modify arguments
-- or want to control execution of the original function.
-- @paramsig [object], method, [handler], [hookSecure]
-- @param object The object to hook a method from
-- @param method If object was specified, the name of the method, or the name of the function to hook.
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked function)
-- @param hookSecure If true, AceHook will allow hooking of secure functions.
-- @usage
-- -- create an addon with AceHook embeded
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0")
--
-- function MyAddon:OnEnable()
-- -- Hook ActionButton_UpdateHotkeys, overwriting the secure status
-- self:RawHook("ActionButton_UpdateHotkeys", true)
-- end
--
-- function MyAddon:ActionButton_UpdateHotkeys(button, type)
-- if button:GetName() == "MyButton" then
-- -- do stuff here
-- else
-- self.hooks.ActionButton_UpdateHotkeys(button, type)
-- end
-- end
function AceHook:RawHook(object, method, handler, hookSecure)
if type(object) == "string" then
method, handler, hookSecure, object = object, method, handler, nil
end
 
if handler == true then
handler, hookSecure = nil, true
end
 
hook(self, object, method, handler, false, false, true, hookSecure or false, "Usage: RawHook([object], method, [handler], [hookSecure])")
end
 
--- SecureHook a function or a method on an object.
-- This function is a wrapper around the `hooksecurefunc` function in the WoW API. Using AceHook
-- extends the functionality of secure hooks, and adds the ability to unhook once the hook isn't
-- required anymore, or the addon is being disabled.\\
-- Secure Hooks should be used if the secure-status of the function is vital to its function,
-- and taint would block execution. Secure Hooks are always called after the original function was called
-- ("Post Hook"), and you cannot modify the arguments, return values or control the execution.
-- @paramsig [object], method, [handler]
-- @param object The object to hook a method from
-- @param method If object was specified, the name of the method, or the name of the function to hook.
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked function)
function AceHook:SecureHook(object, method, handler)
if type(object) == "string" then
method, handler, object = object, method, nil
end
 
hook(self, object, method, handler, false, true, false, false, "Usage: SecureHook([object], method, [handler])")
end
 
--- Hook a script handler on a frame.
-- The hook created will be a "safe hook", that means that your handler will be called
-- before the hooked script ("Pre-Hook"), and you don't have to call the original function yourself,
-- however you cannot stop the execution of the function, or modify any of the arguments/return values.\\
-- This is the frame script equivalent of the :Hook safe-hook. It would typically be used to be notified
-- when a certain event happens to a frame.
-- @paramsig frame, script, [handler]
-- @param frame The Frame to hook the script on
-- @param script The script to hook
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked script)
-- @usage
-- -- create an addon with AceHook embeded
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0")
--
-- function MyAddon:OnEnable()
-- -- Hook the OnShow of FriendsFrame
-- self:HookScript(FriendsFrame, "OnShow", "FriendsFrameOnShow")
-- end
--
-- function MyAddon:FriendsFrameOnShow(frame)
-- print("The FriendsFrame was shown!")
-- end
function AceHook:HookScript(frame, script, handler)
hook(self, frame, script, handler, true, false, false, false, "Usage: HookScript(object, method, [handler])")
end
 
--- RawHook a script handler on a frame.
-- The hook created will be a "raw hook", that means that your handler will completly replace
-- the original script, and your handler has to call the original script (or not, depending on your intentions).\\
-- The original script will be stored in `self.hooks[frame][script]`.\\
-- This type of hook can be used for all purposes, and is usually the most common case when you need to modify arguments
-- or want to control execution of the original script.
-- @paramsig frame, script, [handler]
-- @param frame The Frame to hook the script on
-- @param script The script to hook
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked script)
-- @usage
-- -- create an addon with AceHook embeded
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0")
--
-- function MyAddon:OnEnable()
-- -- Hook the OnShow of FriendsFrame
-- self:RawHookScript(FriendsFrame, "OnShow", "FriendsFrameOnShow")
-- end
--
-- function MyAddon:FriendsFrameOnShow(frame)
-- -- Call the original function
-- self.hooks[frame].OnShow(frame)
-- -- Do our processing
-- -- .. stuff
-- end
function AceHook:RawHookScript(frame, script, handler)
hook(self, frame, script, handler, true, false, true, false, "Usage: RawHookScript(object, method, [handler])")
end
 
--- SecureHook a script handler on a frame.
-- This function is a wrapper around the `frame:HookScript` function in the WoW API. Using AceHook
-- extends the functionality of secure hooks, and adds the ability to unhook once the hook isn't
-- required anymore, or the addon is being disabled.\\
-- Secure Hooks should be used if the secure-status of the function is vital to its function,
-- and taint would block execution. Secure Hooks are always called after the original function was called
-- ("Post Hook"), and you cannot modify the arguments, return values or control the execution.
-- @paramsig frame, script, [handler]
-- @param frame The Frame to hook the script on
-- @param script The script to hook
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked script)
function AceHook:SecureHookScript(frame, script, handler)
hook(self, frame, script, handler, true, true, false, false, "Usage: SecureHookScript(object, method, [handler])")
end
 
--- Unhook from the specified function, method or script.
-- @paramsig [obj], method
-- @param obj The object or frame to unhook from
-- @param method The name of the method, function or script to unhook from.
function AceHook:Unhook(obj, method)
local usage = "Usage: Unhook([obj], method)"
if type(obj) == "string" then
method, obj = obj, nil
end
 
if obj and type(obj) ~= "table" then
error(format("%s: 'obj' - expecting nil or table got %s", usage, type(obj)), 2)
end
if type(method) ~= "string" then
error(format("%s: 'method' - expeting string got %s", usage, type(method)), 2)
end
 
local uid
if obj then
uid = registry[self][obj] and registry[self][obj][method]
else
uid = registry[self][method]
end
 
if not uid or not actives[uid] then
-- Declining to error on an unneeded unhook since the end effect is the same and this would just be annoying.
return false
end
 
actives[uid], handlers[uid] = nil, nil
 
if obj then
registry[self][obj][method] = nil
registry[self][obj] = next(registry[self][obj]) and registry[self][obj] or nil
 
-- if the hook reference doesnt exist, then its a secure hook, just bail out and dont do any unhooking
if not self.hooks[obj] or not self.hooks[obj][method] then return true end
 
if scripts[uid] and obj:GetScript(method) == uid then -- unhooks scripts
obj:SetScript(method, self.hooks[obj][method] ~= donothing and self.hooks[obj][method] or nil)
scripts[uid] = nil
elseif obj and self.hooks[obj] and self.hooks[obj][method] and obj[method] == uid then -- unhooks methods
obj[method] = self.hooks[obj][method]
end
 
self.hooks[obj][method] = nil
self.hooks[obj] = next(self.hooks[obj]) and self.hooks[obj] or nil
else
registry[self][method] = nil
 
-- if self.hooks[method] doesn't exist, then this is a SecureHook, just bail out
if not self.hooks[method] then return true end
 
if self.hooks[method] and _G[method] == uid then -- unhooks functions
_G[method] = self.hooks[method]
end
 
self.hooks[method] = nil
end
return true
end
 
--- Unhook all existing hooks for this addon.
function AceHook:UnhookAll()
for key, value in pairs(registry[self]) do
if type(key) == "table" then
for method in pairs(value) do
self:Unhook(key, method)
end
else
self:Unhook(key)
end
end
end
 
--- Check if the specific function, method or script is already hooked.
-- @paramsig [obj], method
-- @param obj The object or frame to unhook from
-- @param method The name of the method, function or script to unhook from.
function AceHook:IsHooked(obj, method)
-- we don't check if registry[self] exists, this is done by evil magicks in the metatable
if type(obj) == "string" then
if registry[self][obj] and actives[registry[self][obj]] then
return true, handlers[registry[self][obj]]
end
else
if registry[self][obj] and registry[self][obj][method] and actives[registry[self][obj][method]] then
return true, handlers[registry[self][obj][method]]
end
end
 
return false, nil
end
 
--- Upgrade our old embeded
for target, v in pairs( AceHook.embeded ) do
AceHook:Embed( target )
end
mNameplates/Libs/modules.xml New file
0,0 → 1,20
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Script file="LibStub\LibStub.lua"/>
 
<Include file="AceAddon-3.0\AceAddon-3.0.xml"/>
<Include file="LibNameplate-1.0\lib.xml"/>
<Include file="AceDB-3.0\AceDB-3.0.xml"/>
<Include file="AceEvent-3.0\AceEvent-3.0.xml"/>
<Include file="AceHook-3.0\AceHook-3.0.xml"/>
<Include file="AceDBOptions-3.0\AceDBOptions-3.0.xml"/>
<Include file="AceConsole-3.0\AceConsole-3.0.xml"/>
<Include file="AceGUI-3.0\AceGUI-3.0.xml"/>
<Include file="AceHook-3.0\AceHook-3.0.exml"/>
<Include file="LibSharedMedia-3.0\lib.xml"/>
<Include file="AceGUI-3.0-SharedMediaWidgets\widget.xml"/>
<Include file="LibNameplate-1.0\lib.xml"/>
<Script file="LibBackdrop-1.0\LibBackdrop-1.0.lua"/>
 
<Include file="LibGUIFactory-1.0\lib.xml"/>
</Ui>
\ No newline at end of file
mNameplates/mNameplates.toc New file
0,0 → 1,33
## Interface: 40000
## Title: mNameplates
## Notes: Replacement for the default nameplates.
## Author: mangeg
## SavedVariables: mNameplatesDB
## Version: 0.1
## OptionalDeps: LibBackdrop-1.0
## X-Curse-Packaged-Version: r20101026053820
## X-Curse-Project-Name: mNameplates
## X-Curse-Project-ID: mnameplates
## X-Curse-Repository-ID: wow/mnameplates/mainline
 
Libs\modules.xml
 
mNameplates.lua
Utils.lua
 
Filters\Prototype.lua
 
Filters\NameFilter.lua
 
DisplayModules\Prototype.lua
 
DisplayModules\HealthBar.lua
DisplayModules\CastBar.lua
DisplayModules\UnitName.lua
DisplayModules\UnitLevel.lua
DisplayModules\BossIcon.lua
DisplayModules\EliteIcon.lua
DisplayModules\RaidMark.lua
DisplayModules\UnitGuild.lua
DisplayModules\UnitHealthText.lua
DisplayModules\UnitHealthPercent.lua
\ No newline at end of file
mNameplates/DisplayModules/BossIcon.lua New file
0,0 → 1,206
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
local plugin = mNameplates:NewModule("BossIcon")
if not plugin then return end
 
plugin.DisplayName = "Boss Icon"
plugin.DisplayIcon = [[Interface\TARGETINGFRAME\UI-TargetingFrame-Skull]]
 
local AceGUI = LibStub("AceGUI-3.0")
local LSM = LibStub("LibSharedMedia-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
local UIF
local db
 
local Cache = {}
 
local defaults = {
profile = {
Enabled = true,
 
Attached = {
["**"] = {
x = 0,
y = 0,
Point = "RIGHT",
RelPoint = "LEFT",
}
},
AttachedFrame = "NAMEPLATE",
 
Size = 15,
Alpha = 1,
},
global = {
}
}
 
function plugin:OnInitialize()
self.db = mNameplates.db:RegisterNamespace(self:GetName(), defaults)
db = self.db.profile
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetEnabledState(db.Enabled)
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates")
end
 
function plugin:OnEnable()
mNameplates.RegisterCallback(self, "PlateNew")
mNameplates.RegisterCallback(self, "PlateShow")
mNameplates.RegisterCallback(self, "PlateHide")
mNameplates.RegisterCallback(self, "ModuleStateChanged", "ApplyAllPlates")
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
if data then
self:PlateNew("PlateNew", plate, data)
self:PlateShow("PlateShow", plate, data)
end
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
function plugin:OnDisable()
mNameplates.UnregisterAllCallbacks(self)
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
data.BossIcon:ClearAllPoints()
data.BossIcon:SetWidth(0)
data.BossIcon:SetHeight(0)
data.BossIcon:Hide()
tinsert(Cache, data.BossIcon)
data.BossIcon = nil
end
 
 
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Callbacks ~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
function plugin:ProfileChanged(event)
db = self.db.profile
if db.Enabled and not self:IsEnabled() then
self:Enable()
self:ApplyAllPlates()
elseif not db.Enabled and self:IsEnabled() then
self:Disable()
end
end
 
function plugin:PlateNew(event, plate, data)
local BossIcon = table.remove(Cache)
if not BossIcon then
BossIcon = CreateFrame("Frame", nil, data.Background)
BossIcon:SetFrameLevel(plate:GetFrameLevel() + mNameplates.Levels.Icon)
local t = BossIcon:CreateTexture(nil, "ARTOWRK")
t:SetAllPoints()
t:SetTexture([[Interface\TARGETINGFRAME\UI-TargetingFrame-Skull]])
BossIcon.Texture = t
BossIcon:Hide()
end
BossIcon:SetParent(data.Background)
data.BossIcon = BossIcon
end
 
function plugin:PlateShow(event, plate, data)
self:ApplyOnPlate(plate, data)
end
 
function plugin:PlateHide(event, plate, data)
data.BossIcon:Hide()
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Events ~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Settings ~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:ApplyOnPlate(plate, data)
local frame = mNameplates:GetAttachFrame(db.AttachedFrame, plate) or plate
data.BossIcon:ClearAllPoints()
data.BossIcon:SetPoint(db.Attached[db.AttachedFrame].Point, frame, db.Attached[db.AttachedFrame].RelPoint, db.Attached[db.AttachedFrame].x, db.Attached[db.AttachedFrame].y)
 
if Nameplates:IsBoss(plate) then
data.BossIcon:SetAlpha(db.Alpha)
data.BossIcon:SetWidth(db.Size)
data.BossIcon:SetHeight(db.Size)
data.BossIcon:Show()
else
data.BossIcon:SetWidth(0.1)
data.BossIcon:SetHeight(0.1)
data.BossIcon:Hide()
end
end
 
function plugin:ApplyAllPlates()
for i, plate in mNameplates:IteratePlates() do
self:ApplyOnPlate(plate, mNameplates:GetExtra(plate))
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- API ~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:GetAttachFrame(plate)
local data = mNameplates:GetExtra(plate)
return data.BossIcon
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Options ~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
plugin:ApplyAllPlates()
end
 
local options
function plugin:GetOptions()
if options then return options end
options = {
{
data = {{text = "Modules", value = "Modules"}, {text = plugin.DisplayName, value = plugin.DisplayName}},
icon = self.DisplayIcon,
func = function()
local g = AceGUI:Create("SimpleGroup")
g:SetLayout("Flow")
g:SetFullWidth(true)
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not plugin:IsEnabled() then plugin:Enable()
elseif not db.Enabled and plugin:IsEnabled() then plugin:Disable() end
end))
 
local group = UIF:InlineGroup("Attatch")
g:AddChild(group)
group:AddChild(UIF:Dropdown("Frame", db, "AttachedFrame", Callback, mNameplates:GetAttachList(self), 0.5, true))
 
local group = UIF:InlineGroup("Position")
g:AddChild(group)
group:AddChild(UIF:Slider("X", db.Attached[db.AttachedFrame], "x", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Y", db.Attached[db.AttachedFrame], "y", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Dropdown("Point", db.Attached[db.AttachedFrame], "Point", Callback, mNameplates:GetAnchorList(), 0.5, true))
group:AddChild(UIF:Dropdown("Relative Point", db.Attached[db.AttachedFrame], "RelPoint", Callback, mNameplates:GetAnchorList(), 0.5, true))
 
local group = UIF:InlineGroup(" ")
g:AddChild(group)
group:AddChild(UIF:Slider("Size", db, "Size", 1, 100, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Alpha", db, "Alpha", 0, 1, 0.01, Callback, 0.5))
 
return g
end
}
}
return options
end
end
\ No newline at end of file
mNameplates/DisplayModules/CastBar.lua New file
0,0 → 1,344
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
local plugin = mNameplates:NewModule("CastBar", "AceEvent-3.0", "AceHook-3.0")
if not plugin then return end
 
plugin.DisplayName = "Cast Bar"
plugin.DisplayIcon = [[Interface\Icons\inv_misc_bandage_frostweave_heavy]]
 
local AceGUI = LibStub("AceGUI-3.0")
local LSM = LibStub("LibSharedMedia-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
local UIF
local db
 
local Cache = {}
 
local defaults = {
profile = {
Enabled = true,
x = 0,
y = 20,
Width = 125,
Height = 12,
ColorInteruptable = {1, 1, 1, 1},
ColorNotInteruptable = {1, 0, 0, 1},
Attached = {
["**"] = {
x = 0,
y = 0,
Point = "TOP",
RelPoint = "BOTTOM",
}
},
AttachedFrame = "HealthBars",
Texture = "HalD",
 
Font = "accid",
FontSize = 10,
FontFlags = "OUTLINE",
FontColor = {1, 1, 1, 1},
FontShadow = true,
FontShadowX = 1,
FontShadowY = -1,
FontShadowColor = {0, 0, 0, 1},
},
global = {
}
}
 
function plugin:OnInitialize()
self.db = mNameplates.db:RegisterNamespace(self:GetName(), defaults)
db = self.db.profile
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetEnabledState(db.Enabled)
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates")
end
 
function plugin:OnEnable()
mNameplates.RegisterCallback(self, "PlateNew")
mNameplates.RegisterCallback(self, "PlateShow")
mNameplates.RegisterCallback(self, "PlateHide")
mNameplates.RegisterCallback(self, "ModuleStateChanged", "ApplyAllPlates")
 
self:RegisterEvent("UNIT_SPELLCAST_START", "SpellCast")
self:RegisterEvent("UNIT_SPELLCAST_STOP", "SpellCast")
self:RegisterEvent("UNIT_SPELLCAST_CHANNEL_START", "SpellChannel")
self:RegisterEvent("UNIT_SPELLCAST_CHANNEL_STOP", "SpellChannel")
self:RegisterEvent("UNIT_SPELLCAST_CHANNEL_UPDATE", "SpellChannel")
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
if data then
self:PlateNew("PlateNew", plate, data)
self:PlateShow("PlateShow", plate, data)
end
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
function plugin:OnDisable()
mNameplates.UnregisterAllCallbacks(self)
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
data.CastBar.background:ClearAllPoints()
data.CastBar.background:Hide()
data.CastBar.background:SetWidth(0.01)
data.CastBar.background:SetHeight(0.01)
tinsert(Cache, data.CastBar)
data.CastBar = nil
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Callbacks ~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
function plugin:ProfileChanged(event)
db = self.db.profile
if db.Enabled then
if not self:IsEnabled() then self:Enable() end
self:ApplyAllPlates()
elseif not db.Enabled and self:IsEnabled() then
self:Disable()
end
end
 
local function CastBarChanged(self, value)
local plate = self:GetParent()
local data = mNameplates:GetExtra(plate)
data.CastBar:SetValue(value)
if data.CastBar.EndTime then
data.CastBar.SpellTime:SetText(("%.1f"):format((data.CastBar.EndTime / 1000 - GetTime())))
end
end
 
function plugin:PlateNew(event, plate, data)
local bar = table.remove(Cache)
self:HookScript(plate.DefaultItems.CastBar, "OnValueChanged", CastBarChanged)
if not bar then
local background = CreateFrame("Frame", nil, data.Background)
 
bar = CreateFrame("StatusBar", nil, background)
bar:SetMinMaxValues(0, 1)
data.CastBar = bar
bar.background = background
 
local texture = background:CreateTexture()
texture:SetAllPoints()
texture:SetTexture(0, 0, 0, 0.5)
 
local icon = background:CreateTexture()
icon:SetTexCoord(0.08, 0.92, 0.08, 0.92)
bar.icon = icon
 
local text = bar:CreateFontString(nil, "ARTWORK", "GameFontNormal")
text:SetJustifyH("LEFT")
text:SetPoint("TOPLEFT", 2, 0)
text:SetPoint("BOTTOMLEFT", 2, 0)
bar.SpellTime = text
 
text = bar:CreateFontString(nil, "ARTWORK", "GameFontNormal")
text:SetJustifyH("RIGHT")
text:SetPoint("TOPRIGHT", -2, 0)
text:SetPoint("BOTTOMLEFT", bar.SpellTime, "BOTTOMRIGHT", 2, 0)
bar.SpellText = text
 
self:ApplyOnPlate(plate, data)
end
bar.background:SetParent(data.Background)
bar.background:Hide()
data.CastBar = bar
end
 
 
function plugin:PlateShow(event, plate, data)
self:ApplyOnPlate(plate, data)
end
 
function plugin:PlateHide(event, plate, data)
data.CastBar.background:Hide()
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Events ~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:SpellCast(event, unit)
if unit == "player" then return end
if event == "UNIT_SPELLCAST_START" then
local plate = Nameplates:GetNameplateByUnit(unit)
if plate then
local data = mNameplates:GetExtra(plate)
local spell, rank, displayName, icon, startTime, endTime, isTradeSkill, castID, interrupt = UnitCastingInfo(unit)
data.CastBar.icon:SetTexture(icon)
data.CastBar:SetMinMaxValues(0, (endTime - startTime) / 1000)
data.CastBar.EndTime = endTime
data.CastBar.SpellText:SetText(displayName)
data.CastBar.background:Show()
end
 
elseif event == "UNIT_SPELLCAST_STOP" then
local plate = Nameplates:GetNameplateByUnit(unit)
if plate then
local plate = Nameplates:GetNameplateByUnit(unit)
local data = mNameplates:GetExtra(plate)
data.CastBar.background:Hide()
end
end
end
 
function plugin:SpellChannel(event, unit)
if unit == "player" then return end
if event == "UNIT_SPELLCAST_CHANNEL_START" then
local plate = Nameplates:GetNameplateByUnit(unit)
if plate then
local plate = Nameplates:GetNameplateByUnit(unit)
local data = mNameplates:GetExtra(plate)
local spell, rank, displayName, icon, startTime, endTime, isTradeSkill, castID, interrupt = UnitChannelInfo(unit)
data.CastBar.icon:SetTexture(icon)
data.CastBar:SetMinMaxValues(0, (endTime - startTime) / 1000)
data.CastBar.EndTime = endTime
data.CastBar.SpellText:SetText(displayName)
data.CastBar.background:Show()
end
 
elseif event == "UNIT_SPELLCAST_CHANNEL_STOP" then
local plate = Nameplates:GetNameplateByUnit(unit)
if plate then
local plate = Nameplates:GetNameplateByUnit(unit)
local data = mNameplates:GetExtra(plate)
data.CastBar.background:Hide()
end
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Settings ~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:ApplyOnPlate(plate)
local data = mNameplates:GetExtra(plate)
local frame = mNameplates:GetAttachFrame(db.AttachedFrame, plate) or plate
 
data.CastBar.background:ClearAllPoints()
data.CastBar.background:SetPoint(db.Attached[db.AttachedFrame].Point, frame, db.Attached[db.AttachedFrame].RelPoint, db.Attached[db.AttachedFrame].x, db.Attached[db.AttachedFrame].y)
data.CastBar.background:SetHeight(db.Height)
data.CastBar.background:SetWidth(db.Width)
 
data.CastBar.icon:ClearAllPoints()
data.CastBar.icon:SetPoint("TOPLEFT")
data.CastBar.icon:SetPoint("BOTTOMLEFT")
data.CastBar.icon:SetWidth(data.CastBar.background:GetHeight())
 
data.CastBar:ClearAllPoints()
data.CastBar:SetPoint("TOPLEFT", data.CastBar.icon, "TOPRIGHT", 2, 0)
data.CastBar:SetPoint("BOTTOMRIGHT")
 
data.CastBar:SetStatusBarTexture(LSM:Fetch("statusbar", db.Texture))
data.CastBar:SetStatusBarColor(unpack(db.ColorInteruptable))
 
data.CastBar.SpellText:SetFont(LSM:Fetch("font", db.Font), db.FontSize, db.FontFlags)
data.CastBar.SpellTime:SetFont(LSM:Fetch("font", db.Font), db.FontSize, db.FontFlags)
data.CastBar.SpellText:SetTextColor(unpack(db.FontColor))
data.CastBar.SpellTime:SetTextColor(unpack(db.FontColor))
end
 
function plugin:ApplyAllPlates()
for i, plate in mNameplates:IteratePlates() do
self:ApplyOnPlate(plate)
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- API ~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:GetAttachFrame(plate)
local data = mNameplates:GetExtra(plate)
return data.HealthBar
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Options ~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
plugin:ApplyAllPlates()
end
 
local function Enable()
end
 
local function Disable()
end
 
local FontFlagList = {
OUTLINE = "Outline",
THICKOUTLINE = "Thick Outline",
MONOCHROME = "Monochrome",
NONE = "None",
}
 
local options
function plugin:GetOptions()
if options then return options end
options = {
{
data = {{text = "Modules", value = "Modules"}, {text = self.DisplayName, value = self.DisplayName, order = 1}},
icon = self.DisplayIcon,
func = function()
local g = AceGUI:Create("SimpleGroup")
g:SetLayout("Flow")
g:SetFullWidth(true)
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not plugin:IsEnabled() then plugin:Enable()
elseif not db.Enabled and plugin:IsEnabled() then plugin:Disable() end
end))
 
local group = UIF:InlineGroup("Attatch")
g:AddChild(group)
group:AddChild(UIF:Dropdown("Frame", db, "AttachedFrame", Callback, mNameplates:GetAttachList(self), 0.5, true))
 
local group = UIF:InlineGroup("Position")
g:AddChild(group)
group:AddChild(UIF:Slider("X", db.Attached[db.AttachedFrame], "x", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Y", db.Attached[db.AttachedFrame], "y", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Width", db, "Width", 0, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Height", db, "Height", 0, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Dropdown("Point", db.Attached[db.AttachedFrame], "Point", Callback, mNameplates:GetAnchorList(), 0.5, true))
group:AddChild(UIF:Dropdown("Relative Point", db.Attached[db.AttachedFrame], "RelPoint", Callback, mNameplates:GetAnchorList(), 0.5, true))
 
local group = UIF:InlineGroup("Colors")
g:AddChild(group)
group:AddChild(UIF:ColorSelect("Interuptable", db, "ColorInteruptable", Callback, true, 0.3))
group:AddChild(UIF:ColorSelect("Not Interuptable", db, "ColorNotInteruptable", Callback, true, 0.3))
 
 
g:AddChild(UIF:LSMDropdown("statusbar", "Texture", db, "Texture", Callback, 0.5))
 
local group = UIF:InlineGroup("Font")
group:AddChild(UIF:LSMDropdown("font", "Font", db, "Font", Callback, 0.5))
group:AddChild(UIF:Dropdown("Flags", db, "FontFlags", Callback, FontFlagList, 0.5))
group:AddChild(UIF:Slider("Size", db, "FontSize", 1, 50, 1, Callback, 0.5))
group:AddChild(UIF:NewLine())
 
group:AddChild(UIF:CheckBox("Enable Shadow", db, "FontShadow", Callback, nil, 0.5))
group:AddChild(UIF:ColorSelect("Shadow Color", db, "FontShadowColor", Callback, false, 0.5))
group:AddChild(UIF:Slider("Shadow Offset X", db, "FontShadowX", -30, 30, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Shadow Offset Y", db, "FontShadowY", -30, 30, 0.1, Callback, 0.5))
g:AddChild(group)
 
return g
end
},
}
return options
end
end
mNameplates/DisplayModules/UnitName.lua New file
0,0 → 1,311
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
local plugin = mNameplates:NewModule("UnitName")
if not plugin then return end
 
plugin.DisplayName = "Name"
plugin.DisplayIcon = [[Interface\Icons\spell_arcane_arcanepotency]]
 
local AceGUI = LibStub("AceGUI-3.0")
local LSM = LibStub("LibSharedMedia-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
local UIF
local db
 
local Cache = {}
 
local defaults = {
profile = {
Enabled = true,
 
Attached = {
["**"] = {
x = 0,
y = 0,
Point = "TOP",
RelPoint = "TOP",
}
},
AttachedFrame = "HealthBars",
 
Font = "accid",
FontSize = 10,
FontFlags = "OUTLINE",
FontColor = {157/255, 24/255, 68/255, 1},
FontShadow = true,
FontShadowX = 1,
FontShadowY = -1,
FontShadowColor = {0, 0, 0, 1},
 
Colors = {
["**"] = {
["**"] = {
FRIENDLY = {1, 1, 1, 1},
NEUTRAL = {1, 1, 1, 1},
HOSTILE = {1, 1, 1, 1},
}
},
PLAYER = {
UseHostileClassColor = true,
}
}
},
global = {
}
}
 
function plugin:OnInitialize()
self.db = mNameplates.db:RegisterNamespace(self:GetName(), defaults)
db = self.db.profile
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetEnabledState(db.Enabled)
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates")
end
 
function plugin:OnEnable()
mNameplates.RegisterCallback(self, "PlateNew")
mNameplates.RegisterCallback(self, "PlateShow")
mNameplates.RegisterCallback(self, "PlateHide")
mNameplates.RegisterCallback(self, "PlateShowFiltered")
mNameplates.RegisterCallback(self, "ModuleStateChanged", "ApplyAllPlates")
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
if data then
self:PlateNew("PlateNew", plate, data)
self:PlateShow("PlateShow", plate, data)
end
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
function plugin:OnDisable()
mNameplates.UnregisterAllCallbacks(self)
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
data.NameFrame:ClearAllPoints()
data.NameFrame:Hide()
tinsert(Cache, data.NameFrame)
data.NameFrame = nil
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Callbacks ~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
function plugin:ProfileChanged(event)
db = self.db.profile
if db.Enabled then
if not self:IsEnabled() then self:Enable() end
self:ApplyAllPlates()
elseif not db.Enabled and self:IsEnabled() then
self:Disable()
end
end
 
function plugin:PlateNew(event, plate, data)
local textFrame = table.remove(Cache)
if not textFrame then
textFrame = CreateFrame("Frame", nil, data.Background)
textFrame:SetWidth(1)
textFrame:SetHeight(1)
local text = textFrame:CreateFontString(nil, nil, "GameFontNormal")
text:SetPoint("CENTER")
textFrame.txt = text
end
textFrame:SetParent(data.Background)
data.NameFrame = textFrame
end
 
function plugin:PlateShow(event, plate, data)
self:ApplyOnPlate(plate)
local name = Nameplates:GetName(plate)
data.NameFrame.txt:SetText(name)
data.NameFrame:SetWidth(data.NameFrame.txt:GetStringWidth())
data.NameFrame:SetHeight(data.NameFrame.txt:GetStringHeight())
end
 
function plugin:PlateShowFiltered(event, plate, data)
self:ApplyOnPlate(plate)
data.NameFrame:ClearAllPoints()
data.NameFrame:SetPoint("TOP", data.Background, "TOP")
local name = Nameplates:GetName(plate)
data.NameFrame.txt:SetText(name)
data.NameFrame:SetWidth(data.NameFrame.txt:GetStringWidth())
data.NameFrame:SetHeight(data.NameFrame.txt:GetStringHeight())
end
 
function plugin:PlateHide(event, plate, data)
data.NameFrame:Hide()
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Events ~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Settings ~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:ApplyOnPlate(plate)
local data = mNameplates:GetExtra(plate)
 
local frame = mNameplates:GetAttachFrame(db.AttachedFrame, plate) or plate
data.NameFrame:ClearAllPoints()
data.NameFrame:SetPoint(db.Attached[db.AttachedFrame].Point, frame, db.Attached[db.AttachedFrame].RelPoint, db.Attached[db.AttachedFrame].x, db.Attached[db.AttachedFrame].y)
data.NameFrame:Show()
 
data.NameFrame.txt:SetFont(LSM:Fetch("font", db.Font), db.FontSize, db.FontFlags)
data.NameFrame.txt:SetTextColor(unpack(db.FontColor))
if db.FontShadow then
data.NameFrame.txt:SetShadowOffset(db.FontShadowX, db.FontShadowY)
data.NameFrame.txt:SetShadowColor(unpack(db.FontShadowColor))
else
data.NameFrame.txt:SetShadowOffset(0, 0)
end
 
local unitType = Nameplates:GetType(plate)
local reaction = Nameplates:GetReaction(plate)
if reaction and unitType then
if unitType == "NPC" then
if Nameplates:IsBoss(plate) then
data.NameFrame.txt:SetTextColor(unpack(db.Colors.NPC.BOSS[reaction]))
elseif Nameplates:IsElite(plate) then
data.NameFrame.txt:SetTextColor(unpack(db.Colors.NPC.ELITE[reaction]))
else
data.NameFrame.txt:SetTextColor(unpack(db.Colors.NPC.NORMAL[reaction]))
end
else
if (reaction == "HOSTILE" and db.Colors.PLAYER.UseHostileClassColor) then
local class = Nameplates:GetClass(plate)
if class then
local c = RAID_CLASS_COLORS[class]
data.NameFrame.txt:SetTextColor(c.r, c.g, c.b)
else
data.NameFrame.txt:SetTextColor(unpack(db.Colors.PLAYER.NORMAL[reaction]))
end
else
data.NameFrame.txt:SetTextColor(unpack(db.Colors.PLAYER.NORMAL[reaction]))
end
end
end
end
 
function plugin:ApplyAllPlates()
for i, plate in mNameplates:IteratePlates() do
self:ApplyOnPlate(plate)
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- API ~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:GetAttachFrame(plate)
local data = mNameplates:GetExtra(plate)
return data.NameFrame
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Options ~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
plugin:ApplyAllPlates()
end
 
local FontFlagList = {
OUTLINE = "Outline",
THICKOUTLINE = "Thick Outline",
MONOCHROME = "Monochrome",
NONE = "None",
}
 
local options
function plugin:GetOptions()
if options then return options end
options = {
{
data = {{text = "Modules", value = "Modules"}, {text="Name", value = "UnitName"}},
icon = self.DisplayIcon,
func = function()
local g = AceGUI:Create("SimpleGroup")
g:SetLayout("Flow")
g:SetFullWidth(true)
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not plugin:IsEnabled() then plugin:Enable()
elseif not db.Enabled and plugin:IsEnabled() then plugin:Disable() end
end))
 
local group = UIF:InlineGroup("Attatch")
g:AddChild(group)
group:AddChild(UIF:Dropdown("Frame", db, "AttachedFrame", Callback, mNameplates:GetAttachList(self), 0.5, true))
 
local group = UIF:InlineGroup("Position")
g:AddChild(group)
group:AddChild(UIF:Slider("X", db.Attached[db.AttachedFrame], "x", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Y", db.Attached[db.AttachedFrame], "y", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Dropdown("Point", db.Attached[db.AttachedFrame], "Point", Callback, mNameplates:GetAnchorList(), 0.5, true))
group:AddChild(UIF:Dropdown("Relative Point", db.Attached[db.AttachedFrame], "RelPoint", Callback, mNameplates:GetAnchorList(), 0.5, true))
 
local group = UIF:InlineGroup("Font")
group:AddChild(UIF:LSMDropdown("font", "Font", db, "Font", Callback, 0.5))
group:AddChild(UIF:Dropdown("Flags", db, "FontFlags", Callback, FontFlagList, 0.5))
group:AddChild(UIF:Slider("Size", db, "FontSize", 1, 50, 1, Callback, 0.5))
group:AddChild(UIF:NewLine())
 
group:AddChild(UIF:CheckBox("Enable Shadow", db, "FontShadow", Callback, nil, 0.5))
group:AddChild(UIF:ColorSelect("Shadow Color", db, "FontShadowColor", Callback, false, 0.5))
group:AddChild(UIF:Slider("Shadow Offset X", db, "FontShadowX", -30, 30, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Shadow Offset Y", db, "FontShadowY", -30, 30, 0.1, Callback, 0.5))
g:AddChild(group)
 
local group = UIF:InlineGroup("Colors")
g:AddChild(group)
local group2 = UIF:InlineGroup2("NPCs")
group:AddChild(group2)
group2:AddChild(UIF:Text1(" ", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Friedly", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Neutral", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Hostile", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Boss", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.BOSS, "FRIENDLY", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.BOSS, "NEUTRAL", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.BOSS, "HOSTILE", Callback, true, 0.25))
group2:AddChild(UIF:Text1("Elite", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.ELITE, "FRIENDLY", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.ELITE, "NEUTRAL", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.ELITE, "HOSTILE", Callback, true, 0.25))
group2:AddChild(UIF:Text1("Normal", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.NORMAL, "FRIENDLY", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.NORMAL, "NEUTRAL", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.NORMAL, "HOSTILE", Callback, true, 0.25))
 
local group2 = UIF:InlineGroup2("Players")
group:AddChild(group2)
group2:AddChild(UIF:CheckBox("Color hostile by class", db.Colors.PLAYER, "UseHostileClassColor", Callback, "Only works in PvP-zones and with the 'Class Colors in Nameplates' option turned on in the Blizzard Interface options"))
group2:AddChild(UIF:Text1(" ", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Friedly", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Hostile", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1(" ", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Normal", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.PLAYER.NORMAL, "FRIENDLY", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.PLAYER.NORMAL, "HOSTILE", Callback, true, 0.25))
group2:AddChild(UIF:Text1(" ", nil, nil, nil, nil, nil, 0.25))
 
return g
end
}
}
return options
end
end
\ No newline at end of file
mNameplates/DisplayModules/UnitGuild.lua New file
0,0 → 1,277
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
local plugin = mNameplates:NewModule("UnitGuild", "AceEvent-3.0")
if not plugin then return end
 
plugin.DisplayName = "Guild"
plugin.DisplayIcon = [[Interface\GuildBankFrame\UI-GuildBankFrame-NewTab]]
 
local AceGUI = LibStub("AceGUI-3.0")
local LSM = LibStub("LibSharedMedia-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
local UIF
local db
 
local Cache = {}
 
PlayerGuild = GetGuildInfo("player")
 
local defaults = {
profile = {
Enabled = false,
 
Attached = {
["**"] = {
x = 0,
y = 0,
Point = "CENTER",
RelPoint = "CENTER",
}
},
AttachedFrame = "NAMEPLATE",
 
GuildCache = {},
SaveCache = true,
 
Font = "accid",
FontSize = 12,
FontFlags = "OUTLINE",
FontColor = {113/255, 255/255, 186/255, 1},
FontColorSameGuild = {236/255, 0/255, 255/255, 1},
FontShadow = true,
FontShadowX = 1,
FontShadowY = -1,
FontShadowColor = {0, 0, 0, 1},
 
Alpha = 1,
},
global = {
}
}
 
function plugin:OnInitialize()
self.db = mNameplates.db:RegisterNamespace(self:GetName(), defaults)
db = self.db.profile
 
if not db.SaveCache then db.GuildCache = {} end
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetEnabledState(db.Enabled)
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates")
end
 
function plugin:OnEnable()
mNameplates.RegisterCallback(self, "PlateNew")
mNameplates.RegisterCallback(self, "PlateShow")
mNameplates.RegisterCallback(self, "PlateHide")
mNameplates.RegisterCallback(self, "PlateShowFiltered")
mNameplates.RegisterCallback(self, "ModuleStateChanged", "ApplyAllPlates")
 
self:RegisterEvent("UPDATE_MOUSEOVER_UNIT")
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
if data then
self:PlateNew("PlateNew", plate, data)
self:PlateShow("PlateShow", plate, data)
end
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
function plugin:OnDisable()
mNameplates.UnregisterAllCallbacks(self)
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
data.Guild:SetWidth(0.1)
data.Guild:SetHeight(0.1)
tinsert(Cache, data.Guild)
data.Guild = nil
end
 
 
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Callbacks ~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
function plugin:ProfileChanged(event)
db = self.db.profile
if db.Enabled then
if not self:IsEnabled() then self:Enable() end
self:ApplyAllPlates()
elseif not db.Enabled and self:IsEnabled() then
self:Disable()
end
end
 
function plugin:PlateNew(event, plate, data)
local Guild = table.remove(Cache)
if not Guild then
Guild = CreateFrame("Frame", nil, data.Background)
Guild:SetFrameLevel(plate:GetFrameLevel() + mNameplates.Levels.Text)
local text = Guild:CreateFontString(nil, "ARTWORK", "GameFontNormal")
text:SetAllPoints()
Guild.text = text
Guild:Hide()
end
Guild:SetParent(data.Background)
data.Guild = Guild
end
 
function plugin:PlateShow(event, plate, data)
self:ApplyOnPlate(plate, data)
end
 
function plugin:PlateShowFiltered(event, plate, data)
self:ApplyOnPlate(plate, data)
data.Guild:ClearAllPoints()
data.Guild:SetPoint("BOTTOM", data.Background, "BOTTOM")
end
 
function plugin:PlateHide(event, plate, data)
data.Guild:Hide()
end
 
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Events ~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:UPDATE_MOUSEOVER_UNIT()
guild = GetGuildInfo("mouseover")
name, realm = UnitName("mouseover")
if guild and name and not realm then
db.GuildCache[name] = guild
local plate = Nameplates:GetNameplateByName(name)
if plate then
self:ApplyOnPlate(plate, mNameplates:GetExtra(plate))
end
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Settings ~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:ApplyOnPlate(plate, data)
local frame = mNameplates:GetAttachFrame(db.AttachedFrame, plate) or plate
data.Guild:ClearAllPoints()
data.Guild:SetPoint(db.Attached[db.AttachedFrame].Point, frame, db.Attached[db.AttachedFrame].RelPoint, db.Attached[db.AttachedFrame].x, db.Attached[db.AttachedFrame].y)
 
local name = Nameplates:GetName(plate)
local guild = db.GuildCache[name]
 
if guild then
data.Guild.text:SetText(guild)
data.Guild:SetWidth(data.Guild.text:GetStringWidth())
data.Guild:SetHeight(data.Guild.text:GetStringHeight())
 
data.Guild.text:SetFont(LSM:Fetch("font", db.Font), db.FontSize, db.FontFlags)
if guild == PlayerGuild then
data.Guild.text:SetTextColor(unpack(db.FontColorSameGuild))
else
data.Guild.text:SetTextColor(unpack(db.FontColor))
end
if db.FontShadow then
data.Guild.text:SetShadowOffset(db.FontShadowX, db.FontShadowY)
data.Guild.text:SetShadowColor(unpack(db.FontShadowColor))
else
data.Guild.text:SetShadowOffset(0, 0)
end
 
data.Guild:Show()
else
data.Guild:SetWidth(0.1)
data.Guild:SetHeight(0.1)
data.Guild:Hide()
end
end
 
function plugin:ApplyAllPlates()
for i, plate in mNameplates:IteratePlates() do
self:ApplyOnPlate(plate, mNameplates:GetExtra(plate))
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- API ~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:GetAttachFrame(plate)
local data = mNameplates:GetExtra(plate)
return data.Guild
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Options ~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
plugin:ApplyAllPlates()
end
 
local FontFlagList = {
OUTLINE = "Outline",
THICKOUTLINE = "Thick Outline",
MONOCHROME = "Monochrome",
NONE = "None",
}
 
local options
function plugin:GetOptions()
if options then return options end
options = {
{
data = {{text = "Modules", value = "Modules"}, {text = plugin.DisplayName, value = plugin.DisplayName}},
icon = self.DisplayIcon,
func = function()
local g = AceGUI:Create("SimpleGroup")
g:SetLayout("Flow")
g:SetFullWidth(true)
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not plugin:IsEnabled() then plugin:Enable()
elseif not db.Enabled and plugin:IsEnabled() then plugin:Disable() end
end, nil, 0.3))
g:AddChild(UIF:CheckBox("Store guild names between sessions", db, "SaveCache", nil, nil, 0.7))
 
local group = UIF:InlineGroup("Attatch")
g:AddChild(group)
group:AddChild(UIF:Dropdown("Frame", db, "AttachedFrame", Callback, mNameplates:GetAttachList(self), 0.5, true))
 
local group = UIF:InlineGroup("Position")
g:AddChild(group)
group:AddChild(UIF:Slider("X", db.Attached[db.AttachedFrame], "x", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Y", db.Attached[db.AttachedFrame], "y", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Dropdown("Point", db.Attached[db.AttachedFrame], "Point", Callback, mNameplates:GetAnchorList(), 0.5, true))
group:AddChild(UIF:Dropdown("Relative Point", db.Attached[db.AttachedFrame], "RelPoint", Callback, mNameplates:GetAnchorList(), 0.5, true))
 
local group = UIF:InlineGroup("Font")
group:AddChild(UIF:LSMDropdown("font", "Font", db, "Font", Callback, 0.5))
group:AddChild(UIF:Dropdown("Flags", db, "FontFlags", Callback, FontFlagList, 0.5))
group:AddChild(UIF:Slider("Size", db, "FontSize", 1, 50, 1, Callback, 0.5))
group:AddChild(UIF:NewLine())
 
group:AddChild(UIF:CheckBox("Enable Shadow", db, "FontShadow", Callback, nil, 0.5))
group:AddChild(UIF:ColorSelect("Shadow Color", db, "FontShadowColor", Callback, false, 0.5))
group:AddChild(UIF:Slider("Shadow Offset X", db, "FontShadowX", -30, 30, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Shadow Offset Y", db, "FontShadowY", -30, 30, 0.1, Callback, 0.5))
g:AddChild(group)
 
local group = UIF:InlineGroup("Colors")
g:AddChild(group)
group:AddChild(UIF:ColorSelect("Color", db, "FontColor", Callback, true, 0.3))
group:AddChild(UIF:ColorSelect("Color (Same Guild)", db, "FontColorSameGuild", Callback, true, 0.6))
 
return g
end
}
}
return options
end
end
\ No newline at end of file
mNameplates/DisplayModules/Prototype.lua New file
0,0 → 1,21
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
 
local DisplayModuleProt = {}
 
function mNameplates:NewDisplayModule(moduleName, ...)
return self:NewModule(moduleName, DisplayModuleProt, ...)
end
 
function DisplayModuleProt:OnInitialize()
end
 
function DisplayModuleProt:OnEnable()
end
 
function DisplayModuleProt:OnDisable()
end
 
function DisplayModuleProt:GetAttachFrame()
error(self:GetName().." does not supply a GetAttachedFrame() function")
end
\ No newline at end of file
mNameplates/DisplayModules/Target.lua New file
0,0 → 1,225
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
local plugin = mNameplates:NewModule("UnitLevel")
if not plugin then return end
 
plugin.DisplayName = "Level"
plugin.DisplayIcon = [[Interface\Icons\achievement_level_80]]
 
local AceGUI = LibStub("AceGUI-3.0")
local LSM = LibStub("LibSharedMedia-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
local UIF
local db
 
local Cache = {}
 
local defaults = {
profile = {
Enabled = true,
 
Attached = {
["**"] = {
x = 0,
y = 0,
Point = "CENTER",
RelPoint = "CENTER",
}
},
AttachedFrame = "NAMEPLAETE",
 
Font = "accid",
FontSize = 12,
FontFlags = "OUTLINE",
FontColor = {157/255, 24/255, 68/255, 1},
FontShadow = true,
FontShadowX = 1,
FontShadowY = -1,
FontShadowColor = {0, 0, 0, 1},
},
global = {
}
}
 
function plugin:OnInitialize()
self.db = mNameplates.db:RegisterNamespace(self:GetName(), defaults)
db = self.db.profile
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetEnabledState(db.Enabled)
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates")
end
 
function plugin:OnEnable()
mNameplates.RegisterCallback(self, "PlateNew")
mNameplates.RegisterCallback(self, "PlateShow")
mNameplates.RegisterCallback(self, "ModuleStateChanged", "ApplyAllPlates")
 
for i, plate in mNameplates:IteratePlates() do
self:PlateNew("PlateNew", plate)
self:PlateShow("PlateShow", plate)
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
function plugin:OnDisable()
mNameplates.UnregisterAllCallbacks(self)
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
data.LevelFrame:ClearAllPoints()
data.LevelFrame:Hide()
tinsert(Cache, data.LevelFrame)
data.LevelFrame = nil
end
 
 
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Callbacks ~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
function plugin:ProfileChanged(event)
db = self.db.profile
if db.Enabled and not self:IsEnabled() then
self:Enable()
self:ApplyAllPlates()
elseif not db.Enabled and self:IsEnabled() then
self:Disable()
end
end
 
function plugin:PlateNew(event, plate)
local data = mNameplates:GetExtra(plate)
local textFrame = table.remove(Cache)
if not textFrame then
textFrame = CreateFrame("Frame", nil, plate)
textFrame:SetWidth(1)
textFrame:SetHeight(1)
local text = textFrame:CreateFontString(nil, nil, "GameFontNormal")
text:SetPoint("LEFT")
textFrame.txt = text
end
textFrame:SetParent(plate)
data.LevelFrame = textFrame
end
 
function plugin:PlateShow(event, plate)
local data = mNameplates:GetExtra(plate)
local level = Nameplates:IsBoss(plate) and (UnitLevel("player") + 3) or Nameplates:GetLevel(plate)
data.LevelFrame.txt:SetText(level ..(Nameplates:IsBoss(plate) and "++" or Nameplates:IsElite(plate) and "+" or ""))
data.LevelFrame:SetWidth(data.LevelFrame.txt:GetStringWidth())
data.LevelFrame:SetHeight(data.LevelFrame.txt:GetStringHeight())
self:ApplyOnPlate(plate)
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Events ~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Settings ~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:ApplyOnPlate(plate)
local data = mNameplates:GetExtra(plate)
 
local frame = mNameplates:GetAttachFrame(db.AttachedFrame, plate) or plate
data.LevelFrame:ClearAllPoints()
data.LevelFrame:SetPoint(db.Attached[db.AttachedFrame].Point, frame, db.Attached[db.AttachedFrame].RelPoint, db.Attached[db.AttachedFrame].x, db.Attached[db.AttachedFrame].y)
data.LevelFrame:Show()
 
data.LevelFrame.txt:SetFont(LSM:Fetch("font", db.Font), db.FontSize, db.FontFlags)
if db.FontShadow then
data.LevelFrame.txt:SetShadowOffset(db.FontShadowX, db.FontShadowY)
data.LevelFrame.txt:SetShadowColor(unpack(db.FontShadowColor))
else
data.LevelFrame.txt:SetShadowOffset(0, 0)
end
 
local level = Nameplates:IsBoss(plate) and (UnitLevel("player") + 3) or Nameplates:GetLevel(plate)
local c = GetQuestDifficultyColor(level)
data.LevelFrame.txt:SetTextColor(c.r, c.g, c.b)
end
 
function plugin:ApplyAllPlates()
for i, plate in mNameplates:IteratePlates() do
self:ApplyOnPlate(plate)
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- API ~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:GetAttachFrame(plate)
local data = mNameplates:GetExtra(plate)
return data.LevelFrame
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Options ~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
plugin:ApplyAllPlates()
end
 
local FontFlagList = {
OUTLINE = "Outline",
THICKOUTLINE = "Thick Outline",
MONOCHROME = "Monochrome",
NONE = "None",
}
 
local options
function plugin:GetOptions()
if options then return options end
options = {
{
data = {{text="Level", value = "UnitLevel"}},
icon = self.DisplayIcon,
func = function()
local g = AceGUI:Create("SimpleGroup")
g:SetLayout("Flow")
g:SetFullWidth(true)
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not plugin:IsEnabled() then plugin:Enable()
elseif not db.Enabled and plugin:IsEnabled() then plugin:Disable() end
end))
 
local group = UIF:InlineGroup("Attatch")
g:AddChild(group)
group:AddChild(UIF:Dropdown("Frame", db, "AttachedFrame", Callback, mNameplates:GetAttachList(self), 0.5, true))
 
local group = UIF:InlineGroup("Position")
g:AddChild(group)
group:AddChild(UIF:Slider("X", db.Attached[db.AttachedFrame], "x", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Y", db.Attached[db.AttachedFrame], "y", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Dropdown("Point", db.Attached[db.AttachedFrame], "Point", Callback, mNameplates:GetAnchorList(), 0.5, true))
group:AddChild(UIF:Dropdown("Relative Point", db.Attached[db.AttachedFrame], "RelPoint", Callback, mNameplates:GetAnchorList(), 0.5, true))
 
local group = UIF:InlineGroup("Font")
group:AddChild(UIF:LSMDropdown("font", "Font", db, "Font", Callback, 0.5))
group:AddChild(UIF:Dropdown("Flags", db, "FontFlags", Callback, FontFlagList, 0.5))
group:AddChild(UIF:Slider("Size", db, "FontSize", 1, 50, 1, Callback, 0.5))
group:AddChild(UIF:NewLine())
 
group:AddChild(UIF:CheckBox("Enable Shadow", db, "FontShadow", Callback, nil, 0.5))
group:AddChild(UIF:ColorSelect("Shadow Color", db, "FontShadowColor", Callback, false, 0.5))
group:AddChild(UIF:Slider("Shadow Offset X", db, "FontShadowX", -30, 30, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Shadow Offset Y", db, "FontShadowY", -30, 30, 0.1, Callback, 0.5))
g:AddChild(group)
 
return g
end
}
}
return options
end
end
\ No newline at end of file
mNameplates/DisplayModules/UnitHealthPercent.lua New file
0,0 → 1,258
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
local plugin = mNameplates:NewModule("UnitHealthPercent", "AceEvent-3.0")
if not plugin then return end
 
plugin.DisplayName = "Health Percent"
plugin.DisplayIcon = [[Interface\Icons\INV_Mushroom_07]]
 
local AceGUI = LibStub("AceGUI-3.0")
local LSM = LibStub("LibSharedMedia-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
local UIF
local db
 
local Cache = {}
 
local RaidMarkCoords = {
{0.00, 0.25, 0.00, 0.25},
{0.25, 0.50, 0.00, 0.25},
{0.50, 0.75, 0.00, 0.25},
{0.75, 1.00, 0.00, 0.25},
{0.00, 0.25, 0.25, 0.50},
{0.25, 0.50, 0.25, 0.50},
{0.50, 0.75, 0.25, 0.50},
{0.75, 1.00, 0.25, 0.50},
}
 
local defaults = {
profile = {
Enabled = true,
 
Attached = {
["**"] = {
x = 0,
y = 0,
Point = "RIGHT",
RelPoint = "RIGHT",
}
},
AttachedFrame = "HealthBars",
 
Font = "accid",
FontSize = 10,
FontFlags = "OUTLINE",
FontColor = {1, 1, 1, 1},
FontShadow = true,
FontShadowX = 1,
FontShadowY = -1,
FontShadowColor = {0, 0, 0, 1},
 
Alpha = 1,
},
global = {
}
}
 
function plugin:OnInitialize()
self.db = mNameplates.db:RegisterNamespace(self:GetName(), defaults)
db = self.db.profile
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetEnabledState(db.Enabled)
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates")
end
 
function plugin:OnEnable()
mNameplates.RegisterCallback(self, "PlateNew")
mNameplates.RegisterCallback(self, "PlateShow")
mNameplates.RegisterCallback(self, "PlateHide")
mNameplates.RegisterCallback(self, "PlateHPChanged")
mNameplates.RegisterCallback(self, "ModuleStateChanged", "ApplyAllPlates")
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
if data then
self:PlateNew("PlateNew", plate, data)
self:PlateShow("PlateShow", plate, data)
end
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
function plugin:OnDisable()
mNameplates.UnregisterAllCallbacks(self)
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
data.HealthPercent:SetWidth(0.1)
data.HealthPercent:SetHeight(0.1)
data.HealthPercent:Hide()
tinsert(Cache, data.HealthPercent)
data.HealthPercent = nil
end
 
 
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Callbacks ~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
function plugin:ProfileChanged(event)
db = self.db.profile
if db.Enabled then
if not self:IsEnabled() then self:Enable() end
self:ApplyAllPlates()
elseif not db.Enabled and self:IsEnabled() then
self:Disable()
end
end
 
function plugin:PlateNew(event, plate, data)
local HealthPercent = table.remove(Cache)
if not HealthPercent then
HealthPercent = CreateFrame("Frame", nil, data.Background)
HealthPercent:SetFrameLevel(plate:GetFrameLevel() + mNameplates.Levels.Text)
local text = HealthPercent:CreateFontString(nil, nil, "GameFontNormal")
text:SetAllPoints()
HealthPercent.text = text
HealthPercent:Hide()
end
HealthPercent:SetParent(data.Background)
data.HealthPercent = HealthPercent
end
 
function plugin:PlateShow(event, plate)
self:ApplyOnPlate(plate)
end
 
function plugin:PlateHPChanged(event, plate, data)
local health, maxHealth = Nameplates:GetHealth(plate), Nameplates:GetHealthMax(plate)
if health and maxHealth then
data.HealthPercent.text:SetText(("%.1f%%"):format(health / maxHealth * 100))
data.HealthPercent:SetWidth(data.HealthPercent.text:GetStringWidth())
data.HealthPercent:SetHeight(data.HealthPercent.text:GetStringHeight())
end
end
 
function plugin:PlateHide(event, plate, data)
data.HealthPercent:Hide()
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Events ~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Settings ~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:ApplyOnPlate(plate)
local data = mNameplates:GetExtra(plate)
 
local frame = mNameplates:GetAttachFrame(db.AttachedFrame, plate) or plate
data.HealthPercent:ClearAllPoints()
data.HealthPercent:SetPoint(db.Attached[db.AttachedFrame].Point, frame, db.Attached[db.AttachedFrame].RelPoint, db.Attached[db.AttachedFrame].x, db.Attached[db.AttachedFrame].y)
 
local health, maxHealth = Nameplates:GetHealth(plate), Nameplates:GetHealthMax(plate)
if health and maxHealth then
data.HealthPercent.text:SetFont(LSM:Fetch("font", db.Font), db.FontSize, db.FontFlags)
data.HealthPercent.text:SetTextColor(unpack(db.FontColor))
if db.FontShadow then
data.HealthPercent.text:SetShadowOffset(db.FontShadowX, db.FontShadowY)
data.HealthPercent.text:SetShadowColor(unpack(db.FontShadowColor))
else
data.HealthPercent.text:SetShadowOffset(0, 0)
end
 
data.HealthPercent.text:SetText(("%.1f%%"):format(health / maxHealth * 100))
data.HealthPercent:SetWidth(data.HealthPercent.text:GetStringWidth())
data.HealthPercent:SetHeight(data.HealthPercent.text:GetStringHeight())
data.HealthPercent:Show()
else
data.HealthPercent:Hide()
end
end
 
function plugin:ApplyAllPlates()
for i, plate in mNameplates:IteratePlates() do
self:ApplyOnPlate(plate)
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- API ~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:GetAttachFrame(plate)
local data = mNameplates:GetExtra(plate)
return data.HealthPercent
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Options ~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
plugin:ApplyAllPlates()
end
 
local FontFlagList = {
OUTLINE = "Outline",
THICKOUTLINE = "Thick Outline",
MONOCHROME = "Monochrome",
NONE = "None",
}
 
local options
function plugin:GetOptions()
if options then return options end
options = {
{
data = {{text = "Modules", value = "Modules"}, {text = plugin.DisplayName, value = plugin.DisplayName}},
icon = self.DisplayIcon,
func = function()
local g = AceGUI:Create("SimpleGroup")
g:SetLayout("Flow")
g:SetFullWidth(true)
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not plugin:IsEnabled() then plugin:Enable()
elseif not db.Enabled and plugin:IsEnabled() then plugin:Disable() end
end))
 
local group = UIF:InlineGroup("Attatch")
g:AddChild(group)
group:AddChild(UIF:Dropdown("Frame", db, "AttachedFrame", Callback, mNameplates:GetAttachList(self), 0.5, true))
 
local group = UIF:InlineGroup("Position")
g:AddChild(group)
group:AddChild(UIF:Slider("X", db.Attached[db.AttachedFrame], "x", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Y", db.Attached[db.AttachedFrame], "y", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Dropdown("Point", db.Attached[db.AttachedFrame], "Point", Callback, mNameplates:GetAnchorList(), 0.5, true))
group:AddChild(UIF:Dropdown("Relative Point", db.Attached[db.AttachedFrame], "RelPoint", Callback, mNameplates:GetAnchorList(), 0.5, true))
 
local group = UIF:InlineGroup("Font")
group:AddChild(UIF:LSMDropdown("font", "Font", db, "Font", Callback, 0.5))
group:AddChild(UIF:Dropdown("Flags", db, "FontFlags", Callback, FontFlagList, 0.5))
group:AddChild(UIF:ColorSelect("Font Color", db, "FontColor", Callback, true, 0.5))
group:AddChild(UIF:Slider("Size", db, "FontSize", 1, 50, 1, Callback, 0.5))
group:AddChild(UIF:NewLine())
 
group:AddChild(UIF:CheckBox("Enable Shadow", db, "FontShadow", Callback, nil, 0.5))
group:AddChild(UIF:ColorSelect("Shadow Color", db, "FontShadowColor", Callback, false, 0.5))
group:AddChild(UIF:Slider("Shadow Offset X", db, "FontShadowX", -30, 30, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Shadow Offset Y", db, "FontShadowY", -30, 30, 0.1, Callback, 0.5))
g:AddChild(group)
 
return g
end
}
}
return options
end
end
\ No newline at end of file
mNameplates/DisplayModules/UnitLevel.lua New file
0,0 → 1,249
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
local plugin = mNameplates:NewModule("UnitLevel")
if not plugin then return end
 
plugin.DisplayName = "Level"
plugin.DisplayIcon = [[Interface\Icons\achievement_level_80]]
 
local AceGUI = LibStub("AceGUI-3.0")
local LSM = LibStub("LibSharedMedia-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
local UIF
local db
 
local Cache = {}
 
local defaults = {
profile = {
Enabled = true,
 
Attached = {
["**"] = {
x = 0,
y = 0,
Point = "LEFT",
RelPoint = "LEFT",
}
},
AttachedFrame = "HealthBars",
 
Font = "accid",
FontSize = 10,
FontFlags = "OUTLINE",
FontColor = {157/255, 24/255, 68/255, 1},
FontShadow = true,
FontShadowX = 1,
FontShadowY = -1,
FontShadowColor = {0, 0, 0, 1},
FontColor = {1, 1, 1, 1},
 
UseDifficultyLevel = true,
ShowWhenBoss = false,
},
global = {
}
}
 
function plugin:OnInitialize()
self.db = mNameplates.db:RegisterNamespace(self:GetName(), defaults)
db = self.db.profile
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetEnabledState(db.Enabled)
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates")
end
 
function plugin:OnEnable()
mNameplates.RegisterCallback(self, "PlateNew")
mNameplates.RegisterCallback(self, "PlateShow")
mNameplates.RegisterCallback(self, "PlateHide")
mNameplates.RegisterCallback(self, "ModuleStateChanged", "ApplyAllPlates")
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
if data then
self:PlateNew("PlateNew", plate, data)
self:PlateShow("PlateShow", plate, data)
end
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
function plugin:OnDisable()
mNameplates.UnregisterAllCallbacks(self)
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
data.LevelFrame:ClearAllPoints()
data.LevelFrame:Hide()
tinsert(Cache, data.LevelFrame)
data.LevelFrame = nil
end
 
 
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Callbacks ~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
function plugin:ProfileChanged(event)
db = self.db.profile
if db.Enabled then
if not self:IsEnabled() then self:Enable() end
self:ApplyAllPlates()
elseif not db.Enabled and self:IsEnabled() then
self:Disable()
end
end
 
function plugin:PlateNew(event, plate, data)
local textFrame = table.remove(Cache)
if not textFrame then
textFrame = CreateFrame("Frame", nil, data.Background)
textFrame:SetFrameLevel(plate:GetFrameLevel() + mNameplates.Levels.Text)
textFrame:SetWidth(1)
textFrame:SetHeight(1)
local text = textFrame:CreateFontString(nil, nil, "GameFontNormal")
text:SetPoint("LEFT")
textFrame.txt = text
end
textFrame:SetParent(data.Background)
data.LevelFrame = textFrame
end
 
function plugin:PlateShow(event, plate, data)
local level = Nameplates:IsBoss(plate) and (UnitLevel("player") + 3) or Nameplates:GetLevel(plate)
data.LevelFrame.txt:SetText(level ..(Nameplates:IsBoss(plate) and "++" or Nameplates:IsElite(plate) and "+" or ""))
data.LevelFrame:SetWidth(data.LevelFrame.txt:GetStringWidth())
data.LevelFrame:SetHeight(data.LevelFrame.txt:GetStringHeight())
self:ApplyOnPlate(plate)
end
 
function plugin:PlateHide(event, plate, data)
data.LevelFrame:Hide()
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Events ~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Settings ~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:ApplyOnPlate(plate)
local data = mNameplates:GetExtra(plate)
 
local frame = mNameplates:GetAttachFrame(db.AttachedFrame, plate) or plate
data.LevelFrame:ClearAllPoints()
data.LevelFrame:SetPoint(db.Attached[db.AttachedFrame].Point, frame, db.Attached[db.AttachedFrame].RelPoint, db.Attached[db.AttachedFrame].x, db.Attached[db.AttachedFrame].y)
data.LevelFrame:Show()
 
data.LevelFrame.txt:SetFont(LSM:Fetch("font", db.Font), db.FontSize, db.FontFlags)
if db.FontShadow then
data.LevelFrame.txt:SetShadowOffset(db.FontShadowX, db.FontShadowY)
data.LevelFrame.txt:SetShadowColor(unpack(db.FontShadowColor))
else
data.LevelFrame.txt:SetShadowOffset(0, 0)
end
 
if db.UseDifficultyLevel then
local level = Nameplates:IsBoss(plate) and (UnitLevel("player") + 3) or Nameplates:GetLevel(plate)
local c = GetQuestDifficultyColor(level)
data.LevelFrame.txt:SetTextColor(c.r, c.g, c.b)
else
data.LevelFrame.txt:SetTextColor(unpack(db.FontColor))
end
 
 
if Nameplates:IsBoss(plate) and not db.ShowWhenBoss then
data.LevelFrame:Hide()
end
end
 
function plugin:ApplyAllPlates()
for i, plate in mNameplates:IteratePlates() do
self:ApplyOnPlate(plate)
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- API ~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:GetAttachFrame(plate)
local data = mNameplates:GetExtra(plate)
return data.LevelFrame
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Options ~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
plugin:ApplyAllPlates()
end
 
local FontFlagList = {
OUTLINE = "Outline",
THICKOUTLINE = "Thick Outline",
MONOCHROME = "Monochrome",
NONE = "None",
}
 
local options
function plugin:GetOptions()
if options then return options end
options = {
{
data = {{text = "Modules", value = "Modules"}, {text="Level", value = "UnitLevel"}},
icon = self.DisplayIcon,
func = function()
local g = AceGUI:Create("SimpleGroup")
g:SetLayout("Flow")
g:SetFullWidth(true)
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not plugin:IsEnabled() then plugin:Enable()
elseif not db.Enabled and plugin:IsEnabled() then plugin:Disable() end
end, nil, 0.3))
 
g:AddChild(UIF:CheckBox("Show when boss", db, "ShowWhenBoss", Callback, nil, 0.3))
g:AddChild(UIF:CheckBox("Color by Difficulty", db, "UseDifficultyLevel", Callback, "Overrides the Font color", 0.35))
 
local group = UIF:InlineGroup("Attatch")
g:AddChild(group)
group:AddChild(UIF:Dropdown("Frame", db, "AttachedFrame", Callback, mNameplates:GetAttachList(self), 0.5, true))
 
local group = UIF:InlineGroup("Position")
g:AddChild(group)
group:AddChild(UIF:Slider("X", db.Attached[db.AttachedFrame], "x", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Y", db.Attached[db.AttachedFrame], "y", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Dropdown("Point", db.Attached[db.AttachedFrame], "Point", Callback, mNameplates:GetAnchorList(), 0.5, true))
group:AddChild(UIF:Dropdown("Relative Point", db.Attached[db.AttachedFrame], "RelPoint", Callback, mNameplates:GetAnchorList(), 0.5, true))
 
local group = UIF:InlineGroup("Font")
group:AddChild(UIF:LSMDropdown("font", "Font", db, "Font", Callback, 0.5))
group:AddChild(UIF:Dropdown("Flags", db, "FontFlags", Callback, FontFlagList, 0.5))
group:AddChild(UIF:ColorSelect("Font Color", db, "FontColor", Callback, true, 0.5))
group:AddChild(UIF:Slider("Size", db, "FontSize", 1, 50, 1, Callback, 0.5))
group:AddChild(UIF:NewLine())
 
group:AddChild(UIF:CheckBox("Enable Shadow", db, "FontShadow", Callback, nil, 0.5))
group:AddChild(UIF:ColorSelect("Shadow Color", db, "FontShadowColor", Callback, false, 0.5))
group:AddChild(UIF:Slider("Shadow Offset X", db, "FontShadowX", -30, 30, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Shadow Offset Y", db, "FontShadowY", -30, 30, 0.1, Callback, 0.5))
g:AddChild(group)
 
return g
end
}
}
return options
end
end
\ No newline at end of file
mNameplates/DisplayModules/SpellICon.lua New file
0,0 → 1,225
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
local plugin = mNameplates:NewModule("UnitLevel")
if not plugin then return end
 
plugin.DisplayName = "Level"
plugin.DisplayIcon = [[Interface\Icons\achievement_level_80]]
 
local AceGUI = LibStub("AceGUI-3.0")
local LSM = LibStub("LibSharedMedia-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
local UIF
local db
 
local Cache = {}
 
local defaults = {
profile = {
Enabled = true,
 
Attached = {
["**"] = {
x = 0,
y = 0,
Point = "CENTER",
RelPoint = "CENTER",
}
},
AttachedFrame = "NAMEPLAETE",
 
Font = "accid",
FontSize = 12,
FontFlags = "OUTLINE",
FontColor = {157/255, 24/255, 68/255, 1},
FontShadow = true,
FontShadowX = 1,
FontShadowY = -1,
FontShadowColor = {0, 0, 0, 1},
},
global = {
}
}
 
function plugin:OnInitialize()
self.db = mNameplates.db:RegisterNamespace(self:GetName(), defaults)
db = self.db.profile
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetEnabledState(db.Enabled)
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates")
end
 
function plugin:OnEnable()
mNameplates.RegisterCallback(self, "PlateNew")
mNameplates.RegisterCallback(self, "PlateShow")
mNameplates.RegisterCallback(self, "ModuleStateChanged", "ApplyAllPlates")
 
for i, plate in mNameplates:IteratePlates() do
self:PlateNew("PlateNew", plate)
self:PlateShow("PlateShow", plate)
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
function plugin:OnDisable()
mNameplates.UnregisterAllCallbacks(self)
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
data.LevelFrame:ClearAllPoints()
data.LevelFrame:Hide()
tinsert(Cache, data.LevelFrame)
data.LevelFrame = nil
end
 
 
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Callbacks ~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
function plugin:ProfileChanged(event)
db = self.db.profile
if db.Enabled and not self:IsEnabled() then
self:Enable()
self:ApplyAllPlates()
elseif not db.Enabled and self:IsEnabled() then
self:Disable()
end
end
 
function plugin:PlateNew(event, plate)
local data = mNameplates:GetExtra(plate)
local textFrame = table.remove(Cache)
if not textFrame then
textFrame = CreateFrame("Frame", nil, plate)
textFrame:SetWidth(1)
textFrame:SetHeight(1)
local text = textFrame:CreateFontString(nil, nil, "GameFontNormal")
text:SetPoint("LEFT")
textFrame.txt = text
end
textFrame:SetParent(plate)
data.LevelFrame = textFrame
end
 
function plugin:PlateShow(event, plate)
local data = mNameplates:GetExtra(plate)
local level = Nameplates:IsBoss(plate) and (UnitLevel("player") + 3) or Nameplates:GetLevel(plate)
data.LevelFrame.txt:SetText(level ..(Nameplates:IsBoss(plate) and "++" or Nameplates:IsElite(plate) and "+" or ""))
data.LevelFrame:SetWidth(data.LevelFrame.txt:GetStringWidth())
data.LevelFrame:SetHeight(data.LevelFrame.txt:GetStringHeight())
self:ApplyOnPlate(plate)
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Events ~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Settings ~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:ApplyOnPlate(plate)
local data = mNameplates:GetExtra(plate)
 
local frame = mNameplates:GetAttachFrame(db.AttachedFrame, plate) or plate
data.LevelFrame:ClearAllPoints()
data.LevelFrame:SetPoint(db.Attached[db.AttachedFrame].Point, frame, db.Attached[db.AttachedFrame].RelPoint, db.Attached[db.AttachedFrame].x, db.Attached[db.AttachedFrame].y)
data.LevelFrame:Show()
 
data.LevelFrame.txt:SetFont(LSM:Fetch("font", db.Font), db.FontSize, db.FontFlags)
if db.FontShadow then
data.LevelFrame.txt:SetShadowOffset(db.FontShadowX, db.FontShadowY)
data.LevelFrame.txt:SetShadowColor(unpack(db.FontShadowColor))
else
data.LevelFrame.txt:SetShadowOffset(0, 0)
end
 
local level = Nameplates:IsBoss(plate) and (UnitLevel("player") + 3) or Nameplates:GetLevel(plate)
local c = GetQuestDifficultyColor(level)
data.LevelFrame.txt:SetTextColor(c.r, c.g, c.b)
end
 
function plugin:ApplyAllPlates()
for i, plate in mNameplates:IteratePlates() do
self:ApplyOnPlate(plate)
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- API ~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:GetAttachFrame(plate)
local data = mNameplates:GetExtra(plate)
return data.LevelFrame
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Options ~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
plugin:ApplyAllPlates()
end
 
local FontFlagList = {
OUTLINE = "Outline",
THICKOUTLINE = "Thick Outline",
MONOCHROME = "Monochrome",
NONE = "None",
}
 
local options
function plugin:GetOptions()
if options then return options end
options = {
{
data = {{text="Level", value = "UnitLevel"}},
icon = self.DisplayIcon,
func = function()
local g = AceGUI:Create("SimpleGroup")
g:SetLayout("Flow")
g:SetFullWidth(true)
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not plugin:IsEnabled() then plugin:Enable()
elseif not db.Enabled and plugin:IsEnabled() then plugin:Disable() end
end))
 
local group = UIF:InlineGroup("Attatch")
g:AddChild(group)
group:AddChild(UIF:Dropdown("Frame", db, "AttachedFrame", Callback, mNameplates:GetAttachList(self), 0.5, true))
 
local group = UIF:InlineGroup("Position")
g:AddChild(group)
group:AddChild(UIF:Slider("X", db.Attached[db.AttachedFrame], "x", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Y", db.Attached[db.AttachedFrame], "y", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Dropdown("Point", db.Attached[db.AttachedFrame], "Point", Callback, mNameplates:GetAnchorList(), 0.5, true))
group:AddChild(UIF:Dropdown("Relative Point", db.Attached[db.AttachedFrame], "RelPoint", Callback, mNameplates:GetAnchorList(), 0.5, true))
 
local group = UIF:InlineGroup("Font")
group:AddChild(UIF:LSMDropdown("font", "Font", db, "Font", Callback, 0.5))
group:AddChild(UIF:Dropdown("Flags", db, "FontFlags", Callback, FontFlagList, 0.5))
group:AddChild(UIF:Slider("Size", db, "FontSize", 1, 50, 1, Callback, 0.5))
group:AddChild(UIF:NewLine())
 
group:AddChild(UIF:CheckBox("Enable Shadow", db, "FontShadow", Callback, nil, 0.5))
group:AddChild(UIF:ColorSelect("Shadow Color", db, "FontShadowColor", Callback, false, 0.5))
group:AddChild(UIF:Slider("Shadow Offset X", db, "FontShadowX", -30, 30, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Shadow Offset Y", db, "FontShadowY", -30, 30, 0.1, Callback, 0.5))
g:AddChild(group)
 
return g
end
}
}
return options
end
end
\ No newline at end of file
mNameplates/DisplayModules/HealthBar.lua New file
0,0 → 1,286
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
local plugin = mNameplates:NewModule("HealthBars")
if not plugin then return end
 
plugin.DisplayName = "Health Bars"
plugin.DisplayIcon = [[Interface\Icons\inv_misc_bandage_frostweave_heavy]]
 
local AceGUI = LibStub("AceGUI-3.0")
local LSM = LibStub("LibSharedMedia-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
local UIF
local db
 
local Cache = {}
 
local defaults = {
profile = {
Enabled = true,
x = 0,
y = 20,
Width = 180,
Height = 12,
Texture = "HalD",
Colors = {
["**"] = {
["**"] = {
FRIENDLY = {73/255, 255/255, 81/255, 1},
NEUTRAL = {255/255, 252/255, 92/255, 1},
HOSTILE = {255/255, 36/255, 0, 1},
}
},
PLAYER = {
UseHostileClassColor = true,
NORMAL = {
FRIENDLY = {103/255, 134/255, 255/255, 1},
},
}
}
},
global = {
}
}
 
function plugin:OnInitialize()
self.db = mNameplates.db:RegisterNamespace(self:GetName(), defaults)
db = self.db.profile
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetEnabledState(db.Enabled)
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates")
end
 
function plugin:OnEnable()
mNameplates.RegisterCallback(self, "PlateNew")
mNameplates.RegisterCallback(self, "PlateShow")
mNameplates.RegisterCallback(self, "PlateHide")
mNameplates.RegisterCallback(self, "PlateHPChanged")
mNameplates.RegisterCallback(self, "PlateMouseover")
mNameplates.RegisterCallback(self, "PlateMouseLeave")
mNameplates.RegisterCallback(self, "ModuleStateChanged", "ApplyAllPlates")
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
if data then
self:PlateNew("PlateNew", plate, data)
self:PlateShow("PlateShow", plate, data)
end
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
function plugin:OnDisable()
mNameplates.UnregisterAllCallbacks(self)
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
data.HealthBar:ClearAllPoints()
data.HealthBar:Hide()
tinsert(Cache, data.HealthBar)
data.HealthBar = nil
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Callbacks ~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
function plugin:ProfileChanged(event)
db = self.db.profile
if db.Enabled then
if not self:IsEnabled() then self:Enable() end
self:ApplyAllPlates()
elseif not db.Enabled and self:IsEnabled() then
self:Disable()
end
end
 
function plugin:PlateNew(event, plate, data)
local bar = table.remove(Cache)
if not bar then
bar = CreateFrame("StatusBar", nil, data.Background)
local highlight = bar:CreateTexture(nil, "OVERLAY")
highlight:SetAllPoints(true)
--highlight:SetPoint("LEFT", bar, "RIGHT")
--highlight:SetWidth(100)
--highlight:SetHeight(100)
highlight:SetVertexColor(1, 1, 1, 0.5)
highlight:Hide()
bar.Highlight = highlight
data.HealthBar = bar
self:ApplyOnPlate(plate, data)
end
bar:SetParent(data.Background)
bar:Hide()
bar:SetPoint("BOTTOMLEFT")
bar:SetPoint("BOTTOMRIGHT")
data.HealthBar = bar
end
 
function plugin:PlateHPChanged(event, plate, data)
local health, maxHealth = Nameplates:GetHealth(plate), Nameplates:GetHealthMax(plate)
data.HealthBar:SetMinMaxValues(0, maxHealth)
data.HealthBar:SetValue(health)
end
 
function plugin:PlateShow(event, plate, data)
self:ApplyOnPlate(plate, data)
self:PlateHPChanged("PlateHPChanged", plate, data)
end
 
function plugin:PlateMouseover(event, plate, data)
data.HealthBar.Highlight:Show()
end
 
function plugin:PlateMouseLeave(event, plate, data)
data.HealthBar.Highlight:Hide()
end
 
function plugin:PlateHide(event, plate, data)
data.HealthBar:Hide()
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Events ~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Settings ~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:ApplyOnPlate(plate)
local data = mNameplates:GetExtra(plate)
data.HealthBar:SetHeight(db.Height)
data.HealthBar:SetStatusBarTexture(LSM:Fetch("statusbar", db.Texture))
data.HealthBar.Highlight:SetTexture(LSM:Fetch("statusbar", db.Texture))
--data.HealthBar.Highlight:SetWidth(db.Width)
--data.HealthBar.Highlight:SetHeight(db.Height)
data.HealthBar:Show()
 
local unitType = Nameplates:GetType(plate)
local reaction = Nameplates:GetReaction(plate)
if reaction and unitType then
if unitType == "NPC" then
if Nameplates:IsBoss(plate) then
data.HealthBar:SetStatusBarColor(unpack(db.Colors.NPC.BOSS[reaction]))
elseif Nameplates:IsElite(plate) then
data.HealthBar:SetStatusBarColor(unpack(db.Colors.NPC.ELITE[reaction]))
else
data.HealthBar:SetStatusBarColor(unpack(db.Colors.NPC.NORMAL[reaction]))
end
else
if (reaction == "HOSTILE" and db.Colors.PLAYER.UseHostileClassColor) then
local class = Nameplates:GetClass(plate)
if class then
local c = RAID_CLASS_COLORS[class]
data.HealthBar:SetStatusBarColor(c.r, c.g, c.b)
else
data.HealthBar:SetStatusBarColor(unpack(db.Colors.PLAYER.NORMAL[reaction]))
end
else
data.HealthBar:SetStatusBarColor(unpack(db.Colors.PLAYER.NORMAL[reaction]))
end
end
end
end
 
function plugin:ApplyAllPlates()
for i, plate in mNameplates:IteratePlates() do
self:ApplyOnPlate(plate)
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- API ~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:GetAttachFrame(plate)
local data = mNameplates:GetExtra(plate)
return data.HealthBar
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Options ~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
plugin:ApplyAllPlates()
end
 
local function Enable()
end
 
local function Disable()
end
 
local options
function plugin:GetOptions()
if options then return options end
options = {
{
data = {{text = "Modules", value = "Modules"}, {text = self.DisplayName, value = "HealthBars", order = 1}},
icon = self.DisplayIcon,
func = function()
local g = AceGUI:Create("SimpleGroup")
g:SetLayout("Flow")
g:SetFullWidth(true)
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not plugin:IsEnabled() then plugin:Enable()
elseif not db.Enabled and plugin:IsEnabled() then plugin:Disable() end
end))
 
local group = UIF:InlineGroup("Position and Size")
g:AddChild(group)
group:AddChild(UIF:Slider("X", db, "x", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Y", db, "y", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Width", db, "Width", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Height", db, "Height", -300, 300, 0.1, Callback, 0.5))
 
local group = UIF:InlineGroup("Colors")
g:AddChild(group)
local group2 = UIF:InlineGroup2("NPCs")
group:AddChild(group2)
group2:AddChild(UIF:Text1(" ", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Friedly", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Neutral", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Hostile", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Boss", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.BOSS, "FRIENDLY", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.BOSS, "NEUTRAL", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.BOSS, "HOSTILE", Callback, true, 0.25))
group2:AddChild(UIF:Text1("Elite", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.ELITE, "FRIENDLY", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.ELITE, "NEUTRAL", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.ELITE, "HOSTILE", Callback, true, 0.25))
group2:AddChild(UIF:Text1("Normal", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.NORMAL, "FRIENDLY", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.NORMAL, "NEUTRAL", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.NPC.NORMAL, "HOSTILE", Callback, true, 0.25))
 
local group2 = UIF:InlineGroup2("Players")
group:AddChild(group2)
group2:AddChild(UIF:CheckBox("Color hostile by class", db.Colors.PLAYER, "UseHostileClassColor", Callback, "Only works in PvP-zones and with the 'Class Colors in Nameplates' option turned on in the Blizzard Interface options"))
group2:AddChild(UIF:Text1(" ", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Friedly", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Hostile", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1(" ", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:Text1("Normal", nil, nil, nil, nil, nil, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.PLAYER.NORMAL, "FRIENDLY", Callback, true, 0.25))
group2:AddChild(UIF:ColorSelect("", db.Colors.PLAYER.NORMAL, "HOSTILE", Callback, true, 0.25))
group2:AddChild(UIF:Text1(" ", nil, nil, nil, nil, nil, 0.25))
 
g:AddChild(UIF:LSMDropdown("statusbar", "Texture", db, "Texture", Callback, 0.5))
 
return g
end
},
}
return options
end
end
mNameplates/DisplayModules/RaidMark.lua New file
0,0 → 1,229
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
local plugin = mNameplates:NewModule("RaidMark", "AceEvent-3.0")
if not plugin then return end
 
plugin.DisplayName = "Raid Mark"
plugin.DisplayIcon = [[Interface\TARGETINGFRAME\UI-RaidTargetingIcon_1]]
 
local AceGUI = LibStub("AceGUI-3.0")
local LSM = LibStub("LibSharedMedia-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
local UIF
local db
 
local Cache = {}
 
local RaidMarkCoords = {
{0.00, 0.25, 0.00, 0.25},
{0.25, 0.50, 0.00, 0.25},
{0.50, 0.75, 0.00, 0.25},
{0.75, 1.00, 0.00, 0.25},
{0.00, 0.25, 0.25, 0.50},
{0.25, 0.50, 0.25, 0.50},
{0.50, 0.75, 0.25, 0.50},
{0.75, 1.00, 0.25, 0.50},
}
 
local defaults = {
profile = {
Enabled = true,
 
Attached = {
["**"] = {
x = 0,
y = 0,
Point = "BOTTOM",
RelPoint = "TOP",
}
},
AttachedFrame = "NAMEPLATE",
 
Size = 20,
Alpha = 1,
},
global = {
}
}
 
function plugin:OnInitialize()
self.db = mNameplates.db:RegisterNamespace(self:GetName(), defaults)
db = self.db.profile
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetEnabledState(db.Enabled)
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates")
end
 
function plugin:OnEnable()
mNameplates.RegisterCallback(self, "PlateNew")
mNameplates.RegisterCallback(self, "PlateShow")
mNameplates.RegisterCallback(self, "PlateHide")
mNameplates.RegisterCallback(self, "PlateShowFiltered")
mNameplates.RegisterCallback(self, "ModuleStateChanged", "ApplyAllPlates")
 
self:RegisterEvent("RAID_TARGET_UPDATE")
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
if data then
self:PlateNew("PlateNew", plate, data)
self:PlateShow("PlateShow", plate, data)
end
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
function plugin:OnDisable()
mNameplates.UnregisterAllCallbacks(self)
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
data.RaidIcon:SetWidth(0.1)
data.RaidIcon:SetHeight(0.1)
data.RaidIcon:Hide()
tinsert(Cache, data.RaidIcon)
data.RaidIcon = nil
end
 
 
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Callbacks ~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
function plugin:ProfileChanged(event)
db = self.db.profile
if db.Enabled then
if not self:IsEnabled() then self:Enable() end
self:ApplyAllPlates()
elseif not db.Enabled and self:IsEnabled() then
self:Disable()
end
end
 
function plugin:PlateNew(event, plate, data)
local RaidIcon = table.remove(Cache)
if not RaidIcon then
RaidIcon = CreateFrame("Frame", nil, data.Background)
RaidIcon:SetFrameLevel(plate:GetFrameLevel() + mNameplates.Levels.Icon)
local t = RaidIcon:CreateTexture(nil, "ARTOWRK")
t:SetAllPoints()
t:SetTexture([[Interface\TARGETINGFRAME\UI-RaidTargetingIcons]])
RaidIcon.Texture = t
RaidIcon:Hide()
end
RaidIcon:SetParent(data.Background)
data.RaidIcon = RaidIcon
end
 
function plugin:PlateShow(event, plate, data)
self:ApplyOnPlate(plate, data)
end
 
function plugin:PlateHide(event, plate, data)
data.RaidIcon:Hide()
end
 
function plugin:PlateShowFiltered(event, plate, data)
self:ApplyOnPlate(plate, data)
data.RaidIcon:ClearAllPoints()
data.RaidIcon:SetPoint("BOTTOM", data.Background, "TOP", 0, 2)
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Events ~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:RAID_TARGET_UPDATE()
self:ApplyAllPlates()
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Settings ~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:ApplyOnPlate(plate, data)
local frame = mNameplates:GetAttachFrame(db.AttachedFrame, plate) or plate
data.RaidIcon:ClearAllPoints()
data.RaidIcon:SetPoint(db.Attached[db.AttachedFrame].Point, frame, db.Attached[db.AttachedFrame].RelPoint, db.Attached[db.AttachedFrame].x, db.Attached[db.AttachedFrame].y)
 
if Nameplates:IsMarked(plate) then
local icon = Nameplates:GetRaidIcon(plate)
data.RaidIcon.Texture:SetTexCoord(unpack(RaidMarkCoords[icon]))
data.RaidIcon:SetWidth(db.Size)
data.RaidIcon:SetHeight(db.Size)
data.RaidIcon:Show()
else
data.RaidIcon:SetWidth(0.1)
data.RaidIcon:SetHeight(0.1)
data.RaidIcon:Hide()
end
end
 
function plugin:ApplyAllPlates()
for i, plate in mNameplates:IteratePlates() do
self:ApplyOnPlate(plate, mNameplates:GetExtra(plate))
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- API ~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:GetAttachFrame(plate)
local data = mNameplates:GetExtra(plate)
return data.BossIcon
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Options ~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
plugin:ApplyAllPlates()
end
 
local options
function plugin:GetOptions()
if options then return options end
options = {
{
data = {{text = "Modules", value = "Modules"}, {text = plugin.DisplayName, value = plugin.DisplayName}},
icon = self.DisplayIcon,
func = function()
local g = AceGUI:Create("SimpleGroup")
g:SetLayout("Flow")
g:SetFullWidth(true)
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not plugin:IsEnabled() then plugin:Enable()
elseif not db.Enabled and plugin:IsEnabled() then plugin:Disable() end
end))
 
local group = UIF:InlineGroup("Attatch")
g:AddChild(group)
group:AddChild(UIF:Dropdown("Frame", db, "AttachedFrame", Callback, mNameplates:GetAttachList(self), 0.5, true))
 
local group = UIF:InlineGroup("Position")
g:AddChild(group)
group:AddChild(UIF:Slider("X", db.Attached[db.AttachedFrame], "x", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Y", db.Attached[db.AttachedFrame], "y", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Dropdown("Point", db.Attached[db.AttachedFrame], "Point", Callback, mNameplates:GetAnchorList(), 0.5, true))
group:AddChild(UIF:Dropdown("Relative Point", db.Attached[db.AttachedFrame], "RelPoint", Callback, mNameplates:GetAnchorList(), 0.5, true))
 
local group = UIF:InlineGroup(" ")
g:AddChild(group)
group:AddChild(UIF:Slider("Size", db, "Size", 1, 100, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Alpha", db, "Alpha", 0, 1, 0.01, Callback, 0.5))
 
return g
end
}
}
return options
end
end
\ No newline at end of file
mNameplates/DisplayModules/UnitHealthText.lua New file
0,0 → 1,247
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
local plugin = mNameplates:NewDisplayModule("UnitHealthText", "AceEvent-3.0")
if not plugin then return end
 
plugin.DisplayName = "Health Text"
plugin.DisplayIcon = [[Interface\Icons\INV_Mushroom_11]]
 
local AceGUI = LibStub("AceGUI-3.0")
local LSM = LibStub("LibSharedMedia-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
local UIF
local db
 
local Cache = {}
 
local RaidMarkCoords = {
{0.00, 0.25, 0.00, 0.25},
{0.25, 0.50, 0.00, 0.25},
{0.50, 0.75, 0.00, 0.25},
{0.75, 1.00, 0.00, 0.25},
{0.00, 0.25, 0.25, 0.50},
{0.25, 0.50, 0.25, 0.50},
{0.50, 0.75, 0.25, 0.50},
{0.75, 1.00, 0.25, 0.50},
}
 
local defaults = {
profile = {
Enabled = false,
 
Attached = {
["**"] = {
x = 0,
y = 0,
Point = "TOPRIGHT",
RelPoint = "BOTTOMRIGHT",
}
},
AttachedFrame = "HealthBars",
 
Font = "accid",
FontSize = 10,
FontFlags = "OUTLINE",
FontColor = {1, 1, 1, 1},
FontShadow = true,
FontShadowX = 1,
FontShadowY = -1,
FontShadowColor = {0, 0, 0, 1},
 
Alpha = 1,
},
global = {
}
}
 
function plugin:OnInitialize()
self.db = mNameplates.db:RegisterNamespace(self:GetName(), defaults)
db = self.db.profile
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetEnabledState(db.Enabled)
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates")
end
 
function plugin:OnEnable()
mNameplates.RegisterCallback(self, "PlateNew")
mNameplates.RegisterCallback(self, "PlateShow")
mNameplates.RegisterCallback(self, "PlateHide")
mNameplates.RegisterCallback(self, "PlateHPChanged")
mNameplates.RegisterCallback(self, "ModuleStateChanged", "ApplyAllPlates")
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
if data then
self:PlateNew("PlateNew", plate, data)
self:PlateShow("PlateShow", plate, data)
end
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
function plugin:OnDisable()
mNameplates.UnregisterAllCallbacks(self)
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
data.HealthText:SetWidth(0.1)
data.HealthText:SetHeight(0.1)
data.HealthText:Hide()
tinsert(Cache, data.HealthText)
data.HealthText = nil
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Callbacks ~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
function plugin:ProfileChanged(event)
db = self.db.profile
if db.Enabled then
if not self:IsEnabled() then self:Enable() end
self:ApplyAllPlates()
elseif not db.Enabled and self:IsEnabled() then
self:Disable()
end
end
 
function plugin:PlateNew(event, plate, data)
local HealthText = table.remove(Cache)
if not HealthText then
HealthText = CreateFrame("Frame", nil, data.Background)
HealthText:SetFrameLevel(plate:GetFrameLevel() + mNameplates.Levels.Icon)
local text = HealthText:CreateFontString(nil, nil, "GameFontNormal")
text:SetAllPoints()
HealthText.text = text
HealthText:Hide()
end
HealthText:SetParent(data.Background)
data.HealthText = HealthText
end
 
function plugin:PlateShow(event, plate, data)
self:ApplyOnPlate(plate, data)
end
 
function plugin:PlateHPChanged(event, plate, data)
local health, maxHealth = Nameplates:GetHealth(plate), Nameplates:GetHealthMax(plate)
if health and maxHealth then
data.HealthText.text:SetText(mNameplates:CondensedNumber(health).." / " ..mNameplates:CondensedNumber(maxHealth))
end
end
 
function plugin:PlateHide(event, plate, data)
data.HealthText:Hide()
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Events ~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Settings ~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:ApplyOnPlate(plate, data)
local frame = mNameplates:GetAttachFrame(db.AttachedFrame, plate) or plate
data.HealthText:ClearAllPoints()
data.HealthText:SetPoint(db.Attached[db.AttachedFrame].Point, frame, db.Attached[db.AttachedFrame].RelPoint, db.Attached[db.AttachedFrame].x, db.Attached[db.AttachedFrame].y)
 
local health, maxHealth = Nameplates:GetHealth(plate), Nameplates:GetHealthMax(plate)
if health and maxHealth then
data.HealthText.text:SetFont(LSM:Fetch("font", db.Font), db.FontSize, db.FontFlags)
data.HealthText.text:SetTextColor(unpack(db.FontColor))
if db.FontShadow then
data.HealthText.text:SetShadowOffset(db.FontShadowX, db.FontShadowY)
data.HealthText.text:SetShadowColor(unpack(db.FontShadowColor))
else
data.HealthText.text:SetShadowOffset(0, 0)
end
 
data.HealthText.text:SetText(mNameplates:CondensedNumber(health).." / " ..mNameplates:CondensedNumber(maxHealth))
data.HealthText:SetWidth(data.HealthText.text:GetStringWidth())
data.HealthText:SetHeight(data.HealthText.text:GetStringHeight())
data.HealthText:Show()
else
data.HealthText:Hide()
end
end
 
function plugin:ApplyAllPlates()
for i, plate in mNameplates:IteratePlates() do
self:ApplyOnPlate(plate, mNameplates:GetExtra(plate))
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- API ~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Options ~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
plugin:ApplyAllPlates()
end
 
local FontFlagList = {
OUTLINE = "Outline",
THICKOUTLINE = "Thick Outline",
MONOCHROME = "Monochrome",
NONE = "None",
}
 
local options
function plugin:GetOptions()
if options then return options end
options = {
{
data = {{text = "Modules", value = "Modules"}, {text = plugin.DisplayName, value = plugin.DisplayName}},
icon = self.DisplayIcon,
func = function()
local g = AceGUI:Create("SimpleGroup")
g:SetLayout("Flow")
g:SetFullWidth(true)
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not plugin:IsEnabled() then plugin:Enable()
elseif not db.Enabled and plugin:IsEnabled() then plugin:Disable() end
end))
 
local group = UIF:InlineGroup("Attatch")
g:AddChild(group)
group:AddChild(UIF:Dropdown("Frame", db, "AttachedFrame", Callback, mNameplates:GetAttachList(self), 0.5, true))
 
local group = UIF:InlineGroup("Position")
g:AddChild(group)
group:AddChild(UIF:Slider("X", db.Attached[db.AttachedFrame], "x", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Y", db.Attached[db.AttachedFrame], "y", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Dropdown("Point", db.Attached[db.AttachedFrame], "Point", Callback, mNameplates:GetAnchorList(), 0.5, true))
group:AddChild(UIF:Dropdown("Relative Point", db.Attached[db.AttachedFrame], "RelPoint", Callback, mNameplates:GetAnchorList(), 0.5, true))
 
local group = UIF:InlineGroup("Font")
group:AddChild(UIF:LSMDropdown("font", "Font", db, "Font", Callback, 0.5))
group:AddChild(UIF:Dropdown("Flags", db, "FontFlags", Callback, FontFlagList, 0.5))
group:AddChild(UIF:Slider("Size", db, "FontSize", 1, 50, 1, Callback, 0.5))
group:AddChild(UIF:NewLine())
 
group:AddChild(UIF:CheckBox("Enable Shadow", db, "FontShadow", Callback, nil, 0.5))
group:AddChild(UIF:ColorSelect("Shadow Color", db, "FontShadowColor", Callback, false, 0.5))
group:AddChild(UIF:Slider("Shadow Offset X", db, "FontShadowX", -30, 30, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Shadow Offset Y", db, "FontShadowY", -30, 30, 0.1, Callback, 0.5))
g:AddChild(group)
 
return g
end
}
}
return options
end
end
\ No newline at end of file
mNameplates/DisplayModules/EliteIcon.lua New file
0,0 → 1,253
local mNameplates = LibStub("AceAddon-3.0"):GetAddon("mNameplates")
if not mNameplates then return end
local plugin = mNameplates:NewModule("EliteIcon")
if not plugin then return end
 
plugin.DisplayName = "Elit Icon"
plugin.DisplayIcon = [[Interface\PvPRankBadges\PvPRank14]]
 
local AceGUI = LibStub("AceGUI-3.0")
local LSM = LibStub("LibSharedMedia-3.0")
local Nameplates = LibStub("LibNameplate-1.0")
local UIF
local db
 
local Cache = {}
 
local TextureMappning = {
["Alliance"] = [[Interface\PvPRankBadges\PvPRankAlliance]],
["Horde"] = [[Interface\PvPRankBadges\PvPRankHorde]],
["Rank 15"] = [[Interface\PvPRankBadges\PvPRank15]],
["Rank 14"] = [[Interface\PvPRankBadges\PvPRank14]],
["Rank 13"] = [[Interface\PvPRankBadges\PvPRank13]],
["Rank 12"] = [[Interface\PvPRankBadges\PvPRank12]],
["Rank 11"] = [[Interface\PvPRankBadges\PvPRank11]],
["Rank 10"] = [[Interface\PvPRankBadges\PvPRank10]],
["Rank 09"] = [[Interface\PvPRankBadges\PvPRank09]],
["Rank 08"] = [[Interface\PvPRankBadges\PvPRank08]],
["Rank 07"] = [[Interface\PvPRankBadges\PvPRank07]],
["Rank 06"] = [[Interface\PvPRankBadges\PvPRank06]],
["Rank 05"] = [[Interface\PvPRankBadges\PvPRank05]],
["Rank 04"] = [[Interface\PvPRankBadges\PvPRank04]],
["Rank 03"] = [[Interface\PvPRankBadges\PvPRank03]],
["Rank 02"] = [[Interface\PvPRankBadges\PvPRank02]],
["Rank 01"] = [[Interface\PvPRankBadges\PvPRank01]],
 
}
 
local defaults = {
profile = {
Enabled = true,
 
Attached = {
["**"] = {
x = 0,
y = -2,
Point = "BOTTOMLEFT",
RelPoint = "TOPLEFT",
}
},
AttachedFrame = "NAMEPLATE",
 
Texture = "Rank 15",
 
Size = 20,
Alpha = 1,
},
global = {
}
}
 
function plugin:OnInitialize()
self.db = mNameplates.db:RegisterNamespace(self:GetName(), defaults)
db = self.db.profile
 
self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged")
self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged")
 
self:SetEnabledState(db.Enabled)
 
UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mNameplates")
end
 
function plugin:OnEnable()
mNameplates.RegisterCallback(self, "PlateNew")
mNameplates.RegisterCallback(self, "PlateShow")
mNameplates.RegisterCallback(self, "PlateHide")
mNameplates.RegisterCallback(self, "ModuleStateChanged", "ApplyAllPlates")
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
if data then
self:PlateNew("PlateNew", plate, data)
self:PlateShow("PlateShow", plate, data)
end
end
 
mNameplates.Callbacks:Fire("ModuleStateChanged", self)
end
 
function plugin:OnDisable()
mNameplates.UnregisterAllCallbacks(self)
 
for i, plate in mNameplates:IteratePlates() do
local data = mNameplates:GetExtra(plate)
data.EliteIcon:ClearAllPoints()
data.EliteIcon:SetWidth(0)
data.EliteIcon:SetHeight(0)
data.EliteIcon:Hide()
tinsert(Cache, data.EliteIcon)
data.EliteIcon = nil
end
 
 
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Callbacks ~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
function plugin:ProfileChanged(event)
db = self.db.profile
if db.Enabled and not self:IsEnabled() then
self:Enable()
self:ApplyAllPlates()
elseif not db.Enabled and self:IsEnabled() then
self:Disable()
end
end
 
function plugin:PlateNew(event, plate, data)
local EliteIcon = table.remove(Cache)
if not EliteIcon then
EliteIcon = CreateFrame("Frame", nil, data.Background)
EliteIcon:SetFrameLevel(plate:GetFrameLevel() + mNameplates.Levels.Icon)
local t = EliteIcon:CreateTexture(nil, "ARTOWRK")
t:SetAllPoints()
EliteIcon.Texture = t
EliteIcon:Hide()
end
EliteIcon:SetParent(data.Background)
data.EliteIcon = EliteIcon
end
 
function plugin:PlateShow(event, plate, data)
self:ApplyOnPlate(plate, data)
end
 
function plugin:PlateHide(event, plate, data)
data.EliteIcon:Hide()
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Events ~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Settings ~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:ApplyOnPlate(plate, data)
local frame = mNameplates:GetAttachFrame(db.AttachedFrame, plate) or plate
data.EliteIcon:ClearAllPoints()
data.EliteIcon:SetPoint(db.Attached[db.AttachedFrame].Point, frame, db.Attached[db.AttachedFrame].RelPoint, db.Attached[db.AttachedFrame].x, db.Attached[db.AttachedFrame].y)
 
if Nameplates:IsElite(plate) and not Nameplates:IsBoss(plate) then
data.EliteIcon:SetAlpha(db.Alpha)
data.EliteIcon:SetWidth(db.Size)
data.EliteIcon:SetHeight(db.Size)
 
data.EliteIcon.Texture:SetTexture(TextureMappning[db.Texture])
 
data.EliteIcon:Show()
else
data.EliteIcon:SetWidth(0.1)
data.EliteIcon:SetHeight(0.1)
data.EliteIcon:Hide()
end
end
 
function plugin:ApplyAllPlates()
for i, plate in mNameplates:IteratePlates() do
self:ApplyOnPlate(plate, mNameplates:GetExtra(plate))
end
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- API ~~~~~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
function plugin:GetAttachFrame(plate)
local data = mNameplates:GetExtra(plate)
return data.EliteIcon
end
 
-- ~~~~~~~~~~~~~~~~~~~~~~
-- Options ~~~~~~~~~~~~~~
-- ~~~~~~~~~~~~~~~~~~~~~~
do
local function Callback()
plugin:ApplyAllPlates()
end
 
local TextureList = {
["Alliance"] = {text = "Alliance", value = "Alliance", icon = TextureMappning["Alliance"]},
["Horde"] = {text = "Horde", value = "Horde", icon = TextureMappning["Horde"]},
["Rank 15"] = {text = "Rank 15", value = "Rank 15", icon = TextureMappning["Rank 15"]},
["Rank 14"] = {text = "Rank 14", value = "Rank 14", icon = TextureMappning["Rank 14"]},
["Rank 13"] = {text = "Rank 13", value = "Rank 13", icon = TextureMappning["Rank 13"]},
["Rank 12"] = {text = "Rank 12", value = "Rank 12", icon = TextureMappning["Rank 12"]},
["Rank 11"] = {text = "Rank 11", value = "Rank 11", icon = TextureMappning["Rank 11"]},
["Rank 10"] = {text = "Rank 10", value = "Rank 10", icon = TextureMappning["Rank 10"]},
["Rank 09"] = {text = "Rank 9", value = "Rank 09", icon = TextureMappning["Rank 09"]},
["Rank 08"] = {text = "Rank 8", value = "Rank 08", icon = TextureMappning["Rank 08"]},
["Rank 07"] = {text = "Rank 7", value = "Rank 07", icon = TextureMappning["Rank 07"]},
["Rank 06"] = {text = "Rank 6", value = "Rank 06", icon = TextureMappning["Rank 06"]},
["Rank 05"] = {text = "Rank 5", value = "Rank 05", icon = TextureMappning["Rank 05"]},
["Rank 04"] = {text = "Rank 4", value = "Rank 04", icon = TextureMappning["Rank 04"]},
["Rank 03"] = {text = "Rank 3", value = "Rank 03", icon = TextureMappning["Rank 03"]},
["Rank 02"] = {text = "Rank 2", value = "Rank 02", icon = TextureMappning["Rank 02"]},
["Rank 01"] = {text = "Rank 1", value = "Rank 01", icon = TextureMappning["Rank 01"]},
}
 
local options
function plugin:GetOptions()
if options then return options end
options = {
{
data = {{text = "Modules", value = "Modules"}, {text = plugin.DisplayName, value = plugin.DisplayName}},
icon = self.DisplayIcon,
func = function()
local g = AceGUI:Create("SimpleGroup")
g:SetLayout("Flow")
g:SetFullWidth(true)
 
g:AddChild(UIF:CheckBox("Enabled", db, "Enabled", function()
if db.Enabled and not plugin:IsEnabled() then plugin:Enable()
elseif not db.Enabled and plugin:IsEnabled() then plugin:Disable() end
end))
 
local group = UIF:InlineGroup("Attatch")
g:AddChild(group)
group:AddChild(UIF:Dropdown("Frame", db, "AttachedFrame", Callback, mNameplates:GetAttachList(self), 0.5, true))
 
local group = UIF:InlineGroup("Position")
g:AddChild(group)
group:AddChild(UIF:Slider("X", db.Attached[db.AttachedFrame], "x", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Y", db.Attached[db.AttachedFrame], "y", -300, 300, 0.1, Callback, 0.5))
group:AddChild(UIF:Dropdown("Point", db.Attached[db.AttachedFrame], "Point", Callback, mNameplates:GetAnchorList(), 0.5, true))
group:AddChild(UIF:Dropdown("Relative Point", db.Attached[db.AttachedFrame], "RelPoint", Callback, mNameplates:GetAnchorList(), 0.5, true))
 
local group = UIF:InlineGroup(" ")
g:AddChild(group)
group:AddChild(UIF:Slider("Size", db, "Size", 1, 100, 0.1, Callback, 0.5))
group:AddChild(UIF:Slider("Alpha", db, "Alpha", 0, 1, 0.01, Callback, 0.5))
 
g:AddChild(UIF:Dropdown("Texture", db, "Texture", Callback, TextureList, 0.5))
 
return g
end
}
}
return options
end
end
\ No newline at end of file
mNameplates/accid.ttf Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes : Added: svn:mime-type + application/octet-stream
mNameplates/Glowing.tga Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes : Added: svn:mime-type + application/octet-stream
mNameplates/Utils.lua New file
0,0 → 1,70
local mNameplates = mNameplates
 
local Nameplates = LibStub("LibNameplate-1.0")
 
do
local OnUpdateFuncs = {}
local FuncElapsed = {}
local UpdateFrame = CreateFrame("Frame")
UpdateFrame:SetScript("OnUpdate", function(self, elapsed)
for module, functions in pairs(OnUpdateFuncs) do
for func, data in pairs(functions) do
if data.updateRate then
data.elapsed = data.elapsed + elapsed
if data.elapsed > data.updateRate then
func(module, data.elapsed)
data.elapsed = 0
end
else
func(module, elapsed)
end
end
end
end)
 
function mNameplates:RegisterOnUpdate(module, func, updateRate)
assert(module and func, "Usage: RegisterOnUpdate(module, func)")
OnUpdateFuncs[module] = OnUpdateFuncs[module] or {}
OnUpdateFuncs[module][func] = {updateRate = updateRate, elapsed = 0}
end
 
function mNameplates:UnregisterOnUpdate(module, func)
assert(module and func, "Usage: UnregisterOnUpdate(module, func")
if OnUpdateFuncs[module] then
OnUpdateFuncs[module][func] = nil
end
end
 
function mNameplates:MouseOverUpdate()
self = mNameplates
local plate = Nameplates:GetNameplateByUnit("mouseover")
if self.CurrentMouseOver and self.CurrentMouseOver ~= plate then
self.Callbacks:Fire("PlateMouseLeave", self.CurrentMouseOver, self:GetExtra(self.CurrentMouseOver))
local data = self:GetExtra(self.CurrentMouseOver)
if data then
for i, frame in pairs(data) do
frame:SetFrameLevel(frame:GetFrameLevel() - 100)
end
end
self.CurrentMouseOver = nil
self:UnregisterOnUpdate(self, self.MouseOverUpdate)
end
end
end
 
function mNameplates:CondensedNumber(value)
assert(value and type(value) == "number", "Usage CondensedNumber(number)")
local result
 
if value > 10000000 then
result = ("%.fm"):format(value/1000000)
elseif value > 1000000 then
result = ("%.2fm"):format(value/1000000)
elseif value > 100000 then
result = ("%.0fk"):format(value/1000)
elseif value > 1000 then
result = ("%.1fk"):format(value/1000)
end
 
return result or value
end
\ No newline at end of file
mNameplates/HalD.tga Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes : Added: svn:mime-type + application/octet-stream