Quantcast
WoWInterface: SVN - oUF_Smee2 - Rev 9 - /trunk/oUF_Smee2/core.lua

WoWInterface SVN oUF_Smee2

[/] [trunk/] [oUF_Smee2/] [core.lua] - Rev 9

Compare with Previous | Blame | View Log

local _G = getfenv(0)
local _,playerClass = UnitClass("player")
local tinsert = table.insert
local layoutName = "oUF_Smee2"
_G[layoutName] = LibStub("AceAddon-3.0"):NewAddon(layoutName,"AceConsole-3.0")
local addon = _G[layoutName];
        addon.LSM = LibStub("LibSharedMedia-3.0")
        addon.build = {}
        addon.build.version, addon.build.build, addon.build.date, addon.build.tocversion = GetBuildInfo()


---------------
--      LDB      --
---------------
local LDB = LibStub:GetLibrary("LibDataBroker-1.1"):NewDataObject(layoutName, {
        label = "|cFF006699oUF|r_|cFFFF3300Smee|r",
        type = "launcher",
        icon = "Interface\\Icons\\Spell_Nature_StormReach",
})


function LDB.OnClick(self, button)
        if button == "RightButton" then
                addon:OpenConfig()
        else
                if addon.db.profile.enabled then
                        if IsAltKeyDown() then
                                if IsControlKeyDown() then
                                        addon:ToggleDebug()
                                end
                        elseif IsShiftKeyDown()  then
--                              addon:DoSomething()
                        end
                else
                        --addon:ToggleActive(true)
                end
        end
end

function addon:ToggleDebug()
        self.enabledDebugMessages=not self.enabledDebugMessages
        self:Print("Debug messages : "..(self.enabledDebugMessages and "ON" or "OFF"))
end

function LDB.OnTooltipShow(tt)
        tt:AddLine(layoutName)
        tt:AddLine("Debugging "..(addon.enabledDebugMessages and "en" or "dis").."abled.")
        tt:AddLine("--")
        tt:AddLine("Ctrl + Alt + Left Click : Toggle Debug Messages")
        tt:AddLine("Right Click : Open Config")
end

local function dummy(arg) end
local function GetClassColor(unit)
        local _,unitClass = UnitClass(unit)
        return unpack(addon.db.profile.colors.class[unitClass])
end
local function menu(self)
        local unit,cunit = self.unit:sub(1, -2), self.unit:gsub("(.)", string.upper, 1)
        if(unit == "party" or unit == "partypet") then
                ToggleDropDownMenu(1, nil, _G["PartyMemberFrame"..self.id.."DropDown"], "cursor", 0, 0)
        elseif(_G[cunit.."FrameDropDown"]) then
                ToggleDropDownMenu(1, nil, _G[cunit.."FrameDropDown"], "cursor", 0, 0)
        end
end 

----------------------
-- helper functions --
----------------------
local function round(num, idp)
  if idp and idp>0 then  return math.floor(num * mult + 0.5) / (10^idp)  end
  return math.floor(num + 0.5)
end
local function numberize(val)
        if(val >= 1e3) then return ("%.1fk"):format(val / 1e3)
        elseif (val >= 1e6) then return ("%.1fm"):format(val / 1e6)
        else return val
        end
end
function Hex(r, g, b)
        if type(r) == "table" then 
                if r.r then r, g, b = r.r, r.g, r.b else r, g, b = unpack(r) end
        end
        return string.format("|cff%02x%02x%02x", r*255, g*255, b*255)
end
local function GetDifficultyColor(level)
        if level == '??' then return  .69,.31,.31
        else
        local levelDiff = UnitLevel('target') - UnitLevel('player')
                if levelDiff >= 5 then
                        return .69,.31,.31
                elseif levelDiff >= 3 then
                        return .71,.43,.27
                elseif levelDiff >= -2 then
                        return .84,.75,.65
                elseif -levelDiff <= GetQuestGreenRange() then
                        return .33,.59,.33
                else
                        return  .55,.57,.61
                end
        end
end
local function GetFormattedTime(s)
        local auraDb = addon.db.profile.auras.timers
        local DAY,HOUR,MINUTE,SHORT = auraDb.values.DAY,auraDb.values.HOUR,auraDb.values.MINUTE,auraDb.values.SHORT
        if s >= DAY then
                return format('%dd', floor(s/DAY + 0.5)), s % DAY
        elseif s >= HOUR then
                return format('%dh', floor(s/HOUR + 0.5)), s % HOUR
        elseif s >= MINUTE then
                if s <= MINUTE*3 and auraDb.UsingMMSS then
                        return format('%d:%02d', floor(s/60), s % MINUTE), s - floor(s)
                end
                return format('%dm', floor(s/MINUTE + 0.5)), s % MINUTE
        elseif s > 2 then
                return floor(s + 0.5), s - floor(s)
        end
        return format("%0.1f", s), 0.1
end
local function GetFormattedFont(s)
        local auraDb = addon.db.profile.auras.timers
        local DAY,HOUR,MINUTE,SHORT = auraDb.values.DAY,auraDb.values.HOUR,auraDb.values.MINUTE,auraDb.values.SHORT
        if s > DAY then
                style = auraDb.cooldownTimerStyle.days
        elseif s > HOUR then
                style = auraDb.cooldownTimerStyle.hrs
        elseif s > MINUTE then
                style = auraDb.cooldownTimerStyle.mins
        elseif s > SHORT then
                style = auraDb.cooldownTimerStyle.secs
        else
                style = auraDb.cooldownTimerStyle.short
        end     
        return style.s, style.r, style.g, style.b
end

------------------
-- UPDATE HOOKS --
------------------
local function updateBanzai(self, unit, aggro)
        if self.unit ~= unit then return end
        if aggro == 1 then self.BanzaiIndicator:Show()
        else self.BanzaiIndicator:Hide() end
end

local function UpdateThreat(self, event, unit)
        if((not unit) or (not event)) or (UnitIsGhost(unit) or UnitIsDead(unit) or (not UnitIsConnected(unit))) then return end
        if unit == "player" or unit:gmatch("raid")() or unit:gmatch("party")() or unit:gmatch("pet")() or unit:gmatch("focus")() or unit:gmatch("target")() then
           unitTarget = unit.."target"
        else
           unitTarget = unit.."-target"
    end   
        local unitTarget = (unit =='player' and "target" or unit.."target")
        
        local isTanking, status, threatpct, rawthreatpct, threatvalue = UnitDetailedThreatSituation(unit, unitTarget);
        if not(rawthreatpct == nil) then 
                self.Threat:SetText( Hex(GetThreatStatusColor(status)) .. string.format("%.0f", rawthreatpct ) .. "|r" )
        else
                self.Threat:SetText('')
        end
end

local function PostUpdateHealth(self, event, unit, bar, min, max)
  bar:SetStatusBarColor(0.25, 0.25, 0.25)      -- Default statusbar color  
  if (UnitIsTapped(unit) and not UnitIsTappedByPlayer(unit) or not UnitIsConnected(unit)) then
    color = self.colors.tapped
  else
    bar:SetStatusBarColor(.25,.25,.35)      -- Default statusbar color
  end
end

local function PostUpdatePower(self, event, unit, bar, min, max)
        if (UnitIsGhost(unit) or UnitIsDead(unit) or not UnitIsConnected(unit)) then 
                bar:SetValue(0)
        end
end

--[[----------------------------------------
        AURA UPDATE HOOKS
----------------------------------------]]--

local function SetAuraPosition(self, icons, x)
        addon:Debug("Repositioning auras.")
        if(icons and x > 0) then
                local col,row = 0,0
                local spacing = icons.spacing or 0
                local size = (icons.size or 16) + spacing
                local anchor = icons.initialAnchor or "BOTTOMLEFT"
                local growthx = (icons["growth-x"] == "LEFT" and -1) or 1
                local growthy = (icons["growth-y"] == "DOWN" and -1) or 1
                local cols = icons.Colomns
--              local rows = icons.Rows  -- Right now only horizontally conditioned aura frames are supported

                for i = 1, x do
                        local button = icons[i]
                        if(button and button:IsShown()) then
                                if(icons.gap and button.debuff) then
                                        if(col > 0) then col = col + 1 end
                                        icons.gap = false
                                end
                                if(col >= cols) then col,row = 0, row + 1 end
                                local anchorFrom,anchorObj,anchorTo
                                local vert = icons["growth-y"] == 'UP' and 'BOTTOM' or 'TOP'
                                if growthx < 0 then -- <<<<
                                        anchorFrom,anchorObj,anchorTo,anchorX,anchorY = vert.."RIGHT",icons[i-1],vert.."LEFT",-spacing, 0
                                        if i == 1 or col == 0 then anchorObj,anchorTo,anchorY =  icons,vert.."RIGHT", (row * size * growthy) end
                                else -- >>>>
                                        anchorFrom,anchorObj,anchorTo,anchorX,anchorY = vert.."LEFT",icons[i-1],vert.."RIGHT",spacing,0
                                        if i == 1 or col == 0 then anchorObj,anchorTo,anchorY = icons,vert.."LEFT", (row * size * growthy) end
                                end
                                addon:Debug("placing aura[".. i.."]"..anchorFrom..":"..tostring(anchorObj)..":"..anchorTo..":"..anchorX..":"..anchorY..".")
                                button:SetWidth(icons.size)
                                button:SetHeight(icons.size)
                                button:ClearAllPoints()
                                button:SetPoint(anchorFrom, anchorObj, anchorTo, anchorX, anchorY)
                                col = col + 1
                        end                     
                end
        end
end

local function PreUpdateAura(event, unit)
end

local function PostUpdateAuraIcon(self,icons, unit, icon, index, offset, filter, isDebuff)
--      print(self.unit,icons, unit, icon, index, offset, filter, isDebuff)
--      if(index > icons.num)then icons[index]:Hide() end
end

local function updateAuraIcon(self,event)
        local db = addon.db.profile
        local name,size,outline = (addon.LSM:Fetch('font',db.auras.font.name) or self.db.profile.fonts.default), db.auras.font.size, db.auras.font.outline
        self.count:SetFont(name,size,outline)
        if(self.duration~=nil and self.timeLeft~=nil) then 
                if(db.auras.timers.enabled)then
                        self.remaining:Show()
                        self.overlay:Show()
                        if(self.duration > 0 or self.timeLeft > 0) then 
                                self.overlay:SetParent(self.cd)
                                local timeLeft = self.timeLeft - GetTime()
                                local multiplier, r, g, b = GetFormattedFont(timeLeft)
                                self.overlay:SetVertexColor(r,g,b,1)
                                self.remaining:SetText(GetFormattedTime(timeLeft)) 
                                self.remaining:SetFont(name,(db.auras.timers.useEnlargedFonts and size * multiplier or size),outline)
                                self.remaining:SetTextColor(r,g,b)
                        end
                else
                        self.remaining:Hide()
                        self.overlay:Hide()
                end
        end
        if(addon.build.tocversion >= 30100)then
                self:SetScale((self.owner == 'player' ) and self:GetParent().playerSize  or 1)
                local frameUnit = self.parent:GetParent().unit
                if frameUnit and self.owner then
                        local frameOwner, buffOwner = UnitGUID(frameUnit),UnitGUID(self.owner)
                        if frameUnit ~='player' and buffOwner == frameOwner then self.ownership:Show() else self.ownership:Hide() end
                end
        else
                self:SetScale(self.isPlayer and self:GetParent().playerSize  or 1)
        end
end

local function PostCreateAuraIcon(self, button, icons, index, debuff)
        local db = addon.db.profile
        local fontPath = addon.LSM:Fetch('font',db.auras.font.name) or self.db.profile.fonts.default

        button.cd:SetReverse()
        button.overlay:SetTexture(self.textures.border)
        button.overlay:SetTexCoord(0, 1, 0, 1)
        button.overlay.Hide = function(self) self:SetVertexColor(0.25, 0.25, 0.25) end

        local ownership = button:CreateTexture(nil, "OVERLAY")
                        ownership:SetTexture(self.textures.border)
                        ownership:SetPoint("TOPLEFT", button,"TOPLEFT", -2,2)
                        ownership:SetPoint("BOTTOMRIGHT", button,"BOTTOMRIGHT",2,-2)
                        ownership:SetTexCoord(0, 1, 0, 1)
                        ownership:Hide()
        button.ownership = ownership
        
        button.count:SetParent(button.cd)
        button.count:SetFont(fontPath, db.frames.font.size, db.frames.font.outline)
        button.count:SetPoint("CENTER",button,"BOTTOM",0,-2)
        
        if (not debuff and self.unit =="player") then
                button:SetScript('OnMouseUp', function(self, mouseButton)
                        if mouseButton == 'RightButton' then
                                CancelUnitBuff('player', index)
                        end
                end)
        end

        local remaining = button.cd:CreateFontString(nil, "OVERLAY")
                remaining:SetFont(fontPath, db.auras.font.size, db.auras.font.outline)
                remaining:SetPoint("CENTER", button, 4, 4)
                remaining:SetJustifyH("CENTER")
        button.remaining = remaining
        button:SetScript('OnUpdate', updateAuraIcon)
end

------------
-- makers --
------------
function addon:makeAuraFrame(obj,auraTypes)
        for _,auraType in pairs(auraTypes)do
                local db =  obj.db[auraType]
                local auraFrame = CreateFrame("Frame", nil, obj)
                        auraFrame.size = db.size * 1.1
                        auraFrame.playerSize = db.playerSize
                        auraFrame:SetHeight(auraFrame.size)
                        auraFrame:SetWidth(auraFrame.size * db.Colomns)
                        auraFrame:SetPoint(db.anchorFromPoint,obj.elements[db.anchorTo],db.anchorToPoint,db.anchorX,db.anchorY)
                        auraFrame.spacing=db.spacing
                        auraFrame.num = db.count
                        auraFrame.Colomns = db.Colomns
                        auraFrame.rows = db.rows                
                        auraFrame["growth-x"] = db["growth-x"]
                        auraFrame["growth-y"] = db["growth-y"]
                        auraFrame.filter = db.filter
                        auraFrame.onlyShowPlayer = db.onlyShowPlayer or nil
                        db.setup = false;
                obj[auraType] = auraFrame;
        end
end


function makeComboPoints(self,anchorFrom,anchorTo,aX,aY)
        local db = addon.db.profile.frames.font
        local fontPath = addon.LSM:Fetch('font',db.name) or self.db.profile.fonts.default

        local cpoints = self:CreateFontString(nil, "OVERLAY")
                          cpoints:SetPoint(anchorFrom, self, anchorTo, aX,aY)
                          cpoints:SetFont(fontPath, db.size, db.outline)
                          cpoints:SetTextColor(1,1,1)
                          cpoints:SetJustifyH("CENTER")
        self.CPoints = cpoints
        self.FontObjects["ComboPoints"] =  { 
                        name = "Combo Points",
                        object = self.CPoints
                }
end

function makeCombatFeedbackText(self)
        if not IsAddOnLoaded("oUF_CombatFeedback") then return end
        local db = addon.db.profile.fonts
        local healthBar = self.bars.Health
        self.CombatFeedbackText = healthBar:CreateFontString(nil, "OVERLAY")
        self.CombatFeedbackText:SetPoint("CENTER", healthBar, "CENTER", 0, 0)
        self.CombatFeedbackText:SetFont(db['default'].name, db['default'].size, db['default'].outline)
        self.CombatFeedbackText.maxAlpha = .8

        self.FontObjects["CombatFeedbackText"] ={
                name = "Combat Feedback Text",
                object =  self.CombatFeedbackText
        }
end


function makeCastBar(self)
        local db = addon.db.profile
        local bar = CreateFrame("StatusBar", nil, self)
        bar:SetBackdrop(self.db.bars.Castbar.Backdrop)
        bar:SetBackdropColor(unpack(self.db.bars.Castbar.BackdropColor))
        bar:SetStatusBarTexture(self.textures.statusbar)
        bar:SetStatusBarColor(unpack(self.db.bars.Castbar.StatusBarColor))      
        bar.reverse = self.db.bars.Castbar.reverse
        
        bar.bg = bar:CreateTexture(nil, "BORDER")
        bar.bg:SetAllPoints(bar)
        bar.bg:SetTexture(unpack(self.db.bars.Castbar.bgColor))
        self.elements["Castbar"] = bar
        bar.elements={
                ['parent'] = self,
                ['self'] = bar,
                ['Castbar'] = bar,
        }
        
        self.db.bars.Castbar.Text.anchorTo = "Castbar"
        bar.Text = addon:makeFontObject(bar,"Cast Name",self.db.bars.Castbar.Text)
        self.FontObjects['CastName']= { 
                name = "Cast Name",
                object = bar.Text
        }
        self.db.bars.Castbar.Time.anchorTo = "Castbar"
        bar.Time = addon:makeFontObject(bar,"Cast Time",self.db.bars.Castbar.Time)
        self.FontObjects["CastTime"] = { 
                name = "Cast Time",
                object = bar.Time
        }

        bar.CustomTimeText = function(self, duration)
                if self.casting then
                        self.Time:SetFormattedText("%.1f", self.max - duration)
                elseif self.channeling then
                        self.Time:SetFormattedText("%.1f", duration)
                end
        end     

        if self.unit == "player" and self.db.bars.Castbar.SafeZone.enabled == true then 
                bar.SafeZone = bar:CreateTexture(nil,"ARTWORK")
                bar.SafeZone:SetTexture(self.textures.statusbar)
                bar.SafeZone:SetVertexColor(unpack(self.db.bars.Castbar.SafeZone.colour))
                bar.SafeZone:SetPoint("TOPRIGHT")
                bar.SafeZone:SetPoint("BOTTOMRIGHT")    
                bar.accurate=true
        end
                
        bar:ClearAllPoints()
        bar:SetPoint(self.db.bars.Castbar.anchorFromPoint,self,self.db.bars.Castbar.anchorToPoint,self.db.bars.Castbar.anchorX,self.db.bars.Castbar.anchorY)

        bar:SetHeight(self.db.bars.Castbar.height)
        bar:SetWidth(self.db.bars.Castbar.width)

        self.bars.Castbar = bar;        
        self.Castbar = bar;
end

function RunePostUpdate(self,settings)
        local runeBar = self:GetParent();
        self:SetWidth(runeBar:GetWidth() / 100 *  settings.width)
        self:SetHeight(runeBar:GetHeight() / 100 *  settings.height)
end

function addon:makeRuneBar(frame)
        if frame.unitClass ~= "DEATHKNIGHT" then return end
        if not IsAddOnLoaded("oUF_SmeeRunes") then 
                self:Error("oUF_SmeeRunes not loaded")
                return
        end
        
        local db = addon.db.profile
        local settings = frame.db.bars.RuneBar

        local rune, runeBarHeight,runeBarWidth=_,(frame.db.height/100) * settings.height, (frame.db.width/100) * settings.width
        local runebar = CreateFrame('Frame', nil, frame)

        runebar:SetParent(frame)
        runebar:SetBackdrop(frame.textures.background)
        runebar:SetBackdropColor(unpack(db.colors.backdropColors))
        runebar:SetHeight(runeBarHeight)
        runebar:SetWidth(runeBarWidth)
        runebar:SetPoint(settings.anchorFromPoint,frame,settings.anchorToPoint,settings.anchorX,settings.anchorY)
        runebar.bars = {}
        runebar.runeMapping = {
                [1] = "BLOOD",
                [2] = "UNHOLY",
                [3] = "FROST",
                [4] = "DEATH",
        }
        runebar:Show()
        runebar.colors=db.colors.runes 
        runebar.OnSizeChange = function()
                for index,bar in pairs(runebar.bars) do
                        bar:RunePostUpdate(settings.runes[index])
                end
        end

        runebar.SetChildOrientation = function(value)
                for index,bar in pairs(runebar.bars) do
                        bar:SetOrientation(value)
                end
        end

        for i = 1, 6 do
                rune = CreateFrame('StatusBar', nil, runebar)
                local runeSetting = settings.runes[i]
                local anchor = runebar.bars[runeSetting.anchorTo] or runebar 
                rune:SetPoint(runeSetting.anchorFromPoint, anchor, runeSetting.anchorToPoint,runeSetting.x,runeSetting.y)
                rune.index=i
                rune:SetStatusBarTexture(frame.textures.statusbar)
                rune:SetStatusBarColor(unpack(db.colors.runes[GetRuneType(i)]))
                rune:SetOrientation(settings.orientation)
                rune:SetBackdrop(frame.textures.background)
                rune:SetBackdropColor(0, 0, 0,0.2)
                rune:SetMinMaxValues(0, 1)
                rune.RunePostUpdate = RunePostUpdate
                rune.bg = rune:CreateTexture(nil, 'BORDER')
                rune.bg:SetAllPoints(rune)
                rune.bg:SetTexture(0, 0, 0,0.3)
                runebar.bars[i] = rune
                rune:RunePostUpdate(runeSetting)
        end
        runebar.OnSizeChange()
        frame.bars.RuneBar = runebar
end


function UpdateTotemBar(self)
        local totembar = self.bars.TotemBar
        if self.unitClass ~= "SHAMAN" or not totembar then return end
        
        local settings = self.db.bars.TotemBar
        local db = addon.db.profile
        local fontDb = db.frames.font -- setting this to the global font option for now, till i work out a per-frame policy.
        local fontName, fontSize, fontOutline = ( addon.LSM:Fetch('font',fontDb.name) or addon.db.profile.fonts.default), fontDb.size, fontDb.outline
        
        totembar:ClearAllPoints()
        totembar:SetPoint(settings.anchorFromPoint, self.elements[settings.anchorTo], settings.anchorToPoint,settings.anchorX,settings.anchorY)
        totembar:SetParent(self)
        totembar:Show()
        totembar:SetBackdropColor(1,1,1,0)

        for index,totem in pairs(totembar.totems)do
                totem.duration:ClearAllPoints()
                totem.duration:SetFont(fontName, fontSize, fontOutline)
                totem.duration:SetPoint(settings.Timer.anchorFromPoint,totem.icon,settings.Timer.anchorToPoint,settings.Timer.anchorX,settings.Timer.anchorY)
                totem:SetScale(settings.scale)
        end
        
end


function addon:makeTotemBar(frame)
        if frame.unitClass ~= "SHAMAN" then return end
        self:Debug("<<CREATING TOTEM FRAME>>")
        local totembar = _G["TotemFrame"]
        totembar.totems={}
        for i=1,TotemFrame:GetNumChildren() do
                local totem = _G["TotemFrameTotem"..i]
                local bg = _G["TotemFrameTotem"..i.."Background"]
                local icon = _G["TotemFrameTotem"..i.."Icon"]
                local duration = _G["TotemFrameTotem"..i.."Duration"]
                local _,oldTotemOverlay = totem:GetChildren()
                bg:Hide()
                oldTotemOverlay:Hide()
                
                local totemOverlay = icon:CreateTexture(nil, "OVERLAY")
                          totemOverlay:SetTexture(frame.textures.border)
                          totemOverlay:SetAllPoints(icon)
                          totemOverlay:SetTexCoord(0, 1, 0, 1)
                          totemOverlay.Hide = function(self) self:SetVertexColor(0.25, 0.25, 0.25) end

                        duration:SetParent(totem)

                        totem.overlay = totemOverlay
                        totem.icon = icon
                        totem.bg = bg
                        totem.duration = duration
                totembar.totems[i] = totem
                
                frame.FontObjects["totem".. i .."Duration"] = {
                        name = "Totem ".. i .." Timer Duration",
                        object = totem.duration
                }
        end
        frame.bars.TotemBar = totembar
end

function RuneButton_OnEnter(self)
        if ( self.tooltipText ) then
                GameTooltip:SetOwner(self, "ANCHOR_RIGHT");
                GameTooltip:SetText(self.tooltipText);
                GameTooltip:Show();
        end
end

function addon:StealBar(self,frame,settings)
        local db = addon.db.profile
        if frame:IsUserPlaced() then
                frame:SetUserPlaced(false) 
        end
        frame:ClearAllPoints()          
        frame:SetPoint(settings.anchorFromPoint, self.elements[settings.anchorTo], settings.anchorToPoint,settings.anchorX,settings.anchorY)
        frame:SetHeight(settings.height)
        frame:SetWidth(settings.width)
end

function UpDateFrameSize(self)
-- update bars dependant on frame size.
        for index,bar in pairs(self.db.bars)do
                if(bar.dependantOnFrameSize)then
                        self.bars[index]:SetHeight( ((self.db.height - 3) / 100 ) * self.db.bars[index].height )
                end
        end
        oUF_PowerSpark_ReapplySettings(self)
end

function addon:makeFontObject(frame,name,data)
        local db = addon.db.profile     
        local parent = frame.elements and frame.elements[data.anchorTo] or frame
        
        -- make our font object, parenting it to the supplied anchor point.
        local fontObject = parent:CreateFontString(nil, "OVERLAY")
                          fontObject:SetJustifyH(data.justifyH)
                          fontObject:SetJustifyV(data.justifyV)
                          fontObject:SetPoint(data.anchorFromPoint, parent,data.anchorToPoint, data.anchorX, data.anchorY)

                          local fontDb = db.frames.font -- setting this to the global font option for now, till i work out a per-frame policy.
                          fontObject:SetFont((self.LSM:Fetch('font',fontDb.name) or self.db.profile.fonts.default), fontDb.size, fontDb.outline)

        -- if the parent frame is the unitframe and therefore has an UpdateTag function, use it.                        
        if(frame.Tag~=nil and data.tag~=nil)then
                fontObject.tag = data.tag
                frame:Tag(fontObject, data.tag)
        end
        
        -- store the fontobject in the parent frames fontobject table.
        if(frame.FontObjects)then
                frame.FontObjects[name] = {
                                name = data.desc,
                                object = fontObject
                }
        end
        
        return fontObject
end

--==========================--
--                                                      --
--              NORMAL STYLE            --
--                                                      --
--==========================--

local layout = function(self, unit)
        local db = addon.db.profile     
        self.FontObjects = {}
        self.Indicators = {}
        self.db = db.frames.units[unit]
        self.colors = colors
        self.menu = menu
        _,self.unitClass = UnitClass(unit)
        self:RegisterForClicks("AnyUp")
        self:SetAttribute("*type2", "menu")
        self:SetScript("OnEnter", UnitFrame_OnEnter)
        self:SetScript("OnLeave", UnitFrame_OnLeave)

        self.BarFade =  self.db.barFading
        self.disallowVehicleSwap =  self.db.disallowVehicleSwap 

        self.textures = {
                background = db.textures.backgrounds[self.db.textures.background],
                statusbar = addon.LSM:Fetch('statusbar',self.db.textures.statusbar),
                border = db.textures.borders[self.db.textures.border],
        }
        self:SetBackdrop(self.textures.background)
        self:SetBackdropColor(unpack(db.colors.backdropColors)) 
        self.elements={
                ["parent"] = self,
                ["UIParent"] = UIParent,
        }
--======--
--      BARS --
--======--
    self.bars = {}
        local health = CreateFrame("StatusBar", nil, self)
        health:SetPoint("TOPLEFT", self,"TOPLEFT", 1,-1)
        health:SetPoint("TOPRIGHT", self,"TOPRIGHT",-1,-1)
        health:SetStatusBarTexture(self.textures.statusbar)
        health:SetHeight(((self.db.height - 3) / 100 ) * self.db.bars.Health.height)

        health.colorTapping =  self.db.bars.Health.colorTapping
        health.colorDisconnected =  self.db.bars.Health.colorDisconnected
        health.colorClass =  self.db.bars.Health.colorClass
        health.colorReaction =  self.db.bars.Health.colorReaction       
        health.reverse = self.db.bars.Health.reverse

        health.bg = health:CreateTexture(nil, "BORDER")
        health.bg:SetAllPoints(health)
        local hpbg = self.db.bars.Health.bgColor
        health.bg:SetTexture(hpbg[1],hpbg[2],hpbg[3],hpbg[4])
        self.elements["Health"] = health
        self.bars.Health = health
        self.hcbParent = health
        self.Health = health
        
        local power = CreateFrame("StatusBar", nil, self)
        power:SetPoint("TOPRIGHT", health, "BOTTOMRIGHT", 0, -1)
        power:SetPoint("TOPLEFT", health, "BOTTOMLEFT", 0, -1)
        power:SetStatusBarTexture(self.textures.statusbar)
        power:SetHeight( ((self.db.height - 3) / 100 ) * self.db.bars.Power.height)

        power.colorTapping =  self.db.bars.Power.colorTapping
        power.colorDisconnected =  self.db.bars.Power.colorDisconnected
        power.colorClass =  self.db.bars.Power.colorClass
        power.colorReaction =  self.db.bars.Power.colorReaction         
        power.reverse = self.db.bars.Power.reverse

        power.OnSizeChange=function(object)
                self.db.bars.Health.height = 100 - self.db.bars.Power.height
                self:OnSizeChange()
        end
        health.OnSizeChange=function(object)
                self.db.bars.Power.height = 100 - self.db.bars.Health.height
                self:OnSizeChange()
        end
        
        
        power.bg = power:CreateTexture(nil, "BORDER")
        power.bg:SetAllPoints(power)
        local ppbg = self.db.bars.Power.bgColor
        power.bg:SetTexture(ppbg[1],ppbg[2],ppbg[3],ppbg[4])
        self.elements["Power"] = power
        self.bars.Power = power
        self.Power = power
        
        for index, data in pairs(self.db.FontObjects) do
                self[index] = addon:makeFontObject(self,index,data)
        end
        
--[[
        if IsAddOnLoaded("oUF_SmeeAFK") and (unit ~= "targettarget" or unit ~= "focustarget") then
                self.AFK = {}
                self.AFK.object = health.text
                self.AFK.Tagger=self
                self.AFK.fontFormat = "|cFFFF0000AFK |cFFFFFFFF%s:%s"   

                self.DC = {}
                self.DC.object = health.text
                self.DC.Tagger=self
                self.DC.fontFormat = "|cFFFF0000D/C |cFFFFFFFF%s:%s"    
        end
--]]

--==========--
--      ICONS   --
--==========--
--Leader Icon
        self.Leader = health:CreateTexture(nil, "OVERLAY")
        self.Leader:SetPoint("TOPLEFT", self, 0, 4)
        self.Leader:SetHeight(10)
        self.Leader:SetWidth(10)
-- Raid Icon
        self.RaidIcon = health:CreateTexture(nil, "OVERLAY")
        self.RaidIcon:SetPoint("TOP", self, 0, 4)
        self.RaidIcon:SetHeight(10)
        self.RaidIcon:SetWidth(10)
--Master Loot Icon
        self.MasterLooter = health:CreateTexture(nil, "OVERLAY")
        self.MasterLooter:SetPoint("TOPLEFT", self, 8, 4)
        self.MasterLooter:SetHeight(10)
        self.MasterLooter:SetWidth(10)

        self:SetAttribute("initial-height", self.db.height)             -- Size
        self:SetAttribute("initial-width", self.db.width)               -- Size         
                
--==========--
--      PLAYER  --
--==========--
        if unit == "player" then
                self.Combat = health:CreateTexture(nil, "OVERLAY")
                self.Combat:SetHeight(24)
                self.Combat:SetWidth(24)
                self.Combat:SetPoint("CENTER", self, "BOTTOMRIGHT", -5, 5)
                self.Combat:SetTexture([[Interface\CharacterFrame\UI-StateIcon]])
                self.Combat:SetTexCoord(1/2, 1, 0.01, 0.5)

        -- Resting Icon
                self.Resting = health:CreateTexture(nil, "OVERLAY")
                self.Resting:SetPoint("TOP", self, 0, 8)
                self.Resting:SetHeight(16)
                self.Resting:SetWidth(16)
                self.Resting:SetTexture('Interface\\CharacterFrame\\UI-StateIcon')
                self.Resting:SetTexCoord(0, 0.5, 0, 0.42)

                if IsAddOnLoaded("oUF_PowerSpark") then
                        self.Spark = power:CreateTexture(nil, "OVERLAY")
                        self.Spark:SetTexture("Interface\\CastingBar\\UI-CastingBar-Spark")
                        self.Spark:SetVertexColor(1, 1, 1, 0.8)
                        self.Spark:SetBlendMode("ADD")
                        self.Spark:SetHeight(power:GetHeight()*4)
                        self.Spark:SetWidth(power:GetHeight())
                end
                
                addon:makeRuneBar(self)
                addon:makeTotemBar(self)
                self.UpdateTotemBar = UpdateTotemBar
                self:UpdateTotemBar()           
                if IsAddOnLoaded("CoolLine") and self.db.bars.CoolLine then
                        addon:StealBar(self,_G["CoolLine"],self.db.bars.CoolLine)
                end
                addon:makeAuraFrame(self,{"Buffs","Debuffs"})
        end

--=====================================--
--      PET 
--=====================================--
        
        if unit == "pet" then
                power.colorPower = true
                power.colorHappiness = true
                addon:makeAuraFrame(self,{"Buffs"})
--              makeComboPoints(self,"RIGHT","LEFT",-9, 3,38,"RIGHT")
        end
--=====================================--
--      PET TARGET
--=====================================--
        if unit == "pettarget" then
                power.colorPower = true
                addon:makeAuraFrame(self,{"Debuffs"})
--              makeComboPoints(self,"RIGHT","LEFT",-9, 3,38,"RIGHT")
        end
--===========--
--      TARGET   --
--===========--
        if unit == "target" then
                addon:makeAuraFrame(self,{"Debuffs","Buffs"})
        end

--===========--
--       FOCUS   --
--===========--
        if unit == "focus" then
                addon:makeAuraFrame(self,{"Buffs","Debuffs"})
        end

--=================--
--       FOCUSTARGET   --
--=================--
        if unit == "focustarget" then
        end     
        
--=================--
--       TARGETTARGET   --
--=================--
        if unit == "targettarget" then
        end     

--==============--
--       CASTBARS   --
--==============--
        if unit and  self.db.bars.Castbar and  self.db.bars.Castbar.enabled then
                makeCastBar(self)
        end
--===============--
--       RANGEFADING   --
--===============--
        self.outsideRangeAlpha = self.db.range.outside
        self.inRangeAlpha = self.db.range.inside
        self.SpellRange = self.db.range.enabled
        
--===================--
--       AGRRO INDICATOR   --
--===================--
        if IsAddOnLoaded("oUF_Banzai") then
                self.Banzai = updateBanzai
                self.BanzaiIndicator = power:CreateTexture(nil, "OVERLAY")
                self.BanzaiIndicator:SetPoint("CENTER", self, 0, 0)
                self.BanzaiIndicator:SetHeight(4)
                self.BanzaiIndicator:SetWidth(4)
                self.BanzaiIndicator:SetTexture(1, .25, .25)
                self.BanzaiIndicator:Hide()
        end
--==============--
--       SMOOTH BARS   --
--==============--
        if IsAddOnLoaded("oUF_Smooth") then
                health.Smooth = true
                power.Smooth = true
        end
--=======================--
--       DEBUFF HIGHLIGHTING   --
--=======================--
        if IsAddOnLoaded("oUF_DebuffHighlight") then 
                self.DebuffHighlightBackdrop = self.db.DebuffHighlightBackdrop
        end
        
--=======================--
-- 
--
        
--===============--
--       EVENT HOOKS   --
--===============--
        self.OnSizeChange = UpDateFrameSize
        self.SetAuraPosition = SetAuraPosition
        self.PostCreateAuraIcon = PostCreateAuraIcon
        self.PostUpdateAuraIcon = PostUpdateAuraIcon
        self.PostUpdateHealth = PostUpdateHealth
        self.PostUpdatePower = PostUpdatePower
        self:SetAttribute("initial-scale", db.frames.scale)
        return self
end

function addon:Debug(msg)
        if not self.db.profile.enabledDebugMessages then return end
        self:Print("|cFFFFFF00Debug : |r"..msg)
end

function addon:Error(msg)
        self:Print("|cFFFF0000Error : |r"..msg)
end

function addon:HideBlizzard()
        local hide = self.db.profile.hideBlizzard
        if(hide.TemporaryEnchantFrame) then 
                TemporaryEnchantFrame:Hide()
                TemporaryEnchantFrame:UnregisterAllEvents()
        end
        if(hide.BuffFrame) then 
                BuffFrame:Hide()
                BuffFrame:UnregisterAllEvents()
        end
end

function addon:reloadui(input)
        ReloadUI()
end

function addon:reloadgfx(input)
        RestartGx()
end

function addon:UpdateFontObject()
end

function addon:UpdateFontObjects(obj,size,name,outline)
        local db = self.db.profile
        
        if obj~=nil and obj.FontObjects then    

                print(tostring(db.frames.font.size),tostring(db.frames.font.name),tostring(db.frames.font.outline))

                for index,font in pairs(obj.FontObjects)do
                        if(font.object:GetObjectType() == "FontString")then
                                font.object:SetFont(addon.LSM:Fetch(addon.LSM.MediaType.FONT, db.frames.font.name),db.frames.font.size,db.frames.font.outline) 
                        end
                end

        else

                if size~= nil then db.frames.font.size = size end
                if name~= nil then db.frames.font.name = name end
                if outline~= nil then db.frames.font.outline = outline end
                
                for index,frame in pairs(addon.units)do
                        if frame.unit ~= nil then 
                                self:UpdateFontObjects(frame)
                        end
                end
        end
        
end


function addon:ImportSharedMedia()
        for name,path in pairs(self.db.profile.textures.statusbars)do
                self.LSM:Register(self.LSM.MediaType.STATUSBAR, name, path)
        end
        for name,data in pairs(self.db.profile.fonts)do
                self.LSM:Register(self.LSM.MediaType.FONT, name, data.name)
        end
end

function addon:OpenConfig(input)
        if(not IsAddOnLoaded(layoutName..'_Config')) then
                LoadAddOn(layoutName..'_Config')
        end
        InterfaceOptionsFrame:Hide()
        LibStub("AceConfigDialog-3.0"):SetDefaultSize(layoutName.."_Config", 700, 650)
        LibStub("AceConfigDialog-3.0"):Open(layoutName.."_Config")

end

function addon:OnInitialize()
        self.db = LibStub("AceDB-3.0"):New(layoutName.."DB",oUF_Smee_Settings)
        self.enabledDebugMessages = addon.db.profile.enabledDebugMessages
        self.units = {}
        self.Layout = layout
        self:HideBlizzard()
        self:RegisterChatCommand("oufsmee", "OpenConfig")
        self:RegisterChatCommand("rl", "reloadui")
        self:RegisterChatCommand("rgfx", "reloadgfx")
        self:ImportSharedMedia()
end

function addon:OnEnable()
        
    -- Called when the addon is enabled
        local db = self.db.profile
        if not db.enabled then
                self:Debug("Disabling")
                self:Disable()
                return
        end


        oUF:CompileTagStringLogic()
        self.enabledDebugMessages = false
        
        oUF:RegisterStyle("normal", self.Layout)
        oUF:SetActiveStyle("normal")
        oUF_Player = oUF:Spawn("player","oUF_Player")
        oUF_Player:SetPoint(
                db.frames.units.player.anchorFromPoint,
                oUF.units[db.frames.units.player.anchorTo] or UIParent,
                db.frames.units.player.anchorToPoint,
                db.frames.units.player.anchorX,
                db.frames.units.player.anchorY)
        self.units.target = oUF:Spawn("target","oUF_Target")
        self.units.target:SetPoint(
                db.frames.units.target.anchorFromPoint,
                oUF.units[db.frames.units.target.anchorTo] or UIParent,
                db.frames.units.target.anchorToPoint,
                db.frames.units.target.anchorX,
                db.frames.units.target.anchorY)
        self.units.focus = oUF:Spawn("focus","oUF_Focus")
        self.units.focus:SetPoint(
                db.frames.units.focus.anchorFromPoint,
                oUF.units[db.frames.units.focus.anchorTo] or UIParent,
                db.frames.units.focus.anchorToPoint,
                db.frames.units.focus.anchorX,
                db.frames.units.focus.anchorY)
        self.units.targettarget = oUF:Spawn("targettarget","oUF_TargetTarget")
        self.units.targettarget:SetPoint(
                db.frames.units.targettarget.anchorFromPoint,
                oUF.units[db.frames.units.targettarget.anchorTo] or UIParent,
                db.frames.units.targettarget.anchorToPoint,
                db.frames.units.targettarget.anchorX,
                db.frames.units.targettarget.anchorY)
        self.units.focustarget = oUF:Spawn("focustarget","oUF_FocusTarget")
        self.units.focustarget:SetPoint(
                db.frames.units.focustarget.anchorFromPoint,
                oUF.units[db.frames.units.focustarget.anchorTo] or UIParent,
                db.frames.units.focustarget.anchorToPoint,
                db.frames.units.focustarget.anchorX,
                db.frames.units.focustarget.anchorY)
        self.units.pet = oUF:Spawn("pet","oUF_Pet")
        self.units.pet:SetPoint(
                db.frames.units.pet.anchorFromPoint,
                oUF.units[db.frames.units.pet.anchorTo] or UIParent,
                db.frames.units.pet.anchorToPoint,
                db.frames.units.pet.anchorX,
                db.frames.units.pet.anchorY)    
        self.units.pettarget = oUF:Spawn("pettarget","oUF_PetTarget")
        self.units.pettarget:SetPoint(
                db.frames.units.pettarget.anchorFromPoint,
                oUF.units[db.frames.units.pettarget.anchorTo] or UIParent,
                db.frames.units.pettarget.anchorToPoint,
                db.frames.units.pettarget.anchorX,
                db.frames.units.pettarget.anchorY)      
                
        self.units = {
                ['player'] = oUF_Player,
                ['target'] = oUF_Target,
                ['targettarget'] = oUF_TargetTarget,
                ['focus'] = oUF_Focus,
                ['focustarget'] = oUF_FocusTarget,
                ['pet'] = oUF_Pet,
                ['pettarget'] = oUF_PetTarget,
        }

end

function addon:OnDisable()
    -- Called when the addon is disabled
        db = self.db.profile
        if db.enabled then
                db.enabled = false
                return
        end
    self:Debug("Disabled")
end

Compare with Previous | Blame