[FixMyCode] beginner working with OnEnter and UIFrameFadeIn

[tonyis3l33t]

Hi all! Wondering if I could get another pair of eyes on this....

trying to get the minimap to fade in when moused over, otherwise be faded out.
What it actually does: nothing

------------------
--Config
local fadeTime = .5		-- fade time in seconds
------------------

local DaftFade = CreateFrame('Frame')


--Events
local event = CreateFrame('Frame')
event:SetScript('OnEvent', function(self, event, ...) self[event](self, ...) end)


--Fading
function DaftFade:FadeIn(frame)
	local alpha = frame:GetAlpha()
	UIFrameFadeIn(frame, fadeTime*(1-alpha), alpha, 1)
end

function DaftFade:FadeOut(frame)
	local alpha = frame:GetAlpha()
	UIFrameFadeOut(frame, fadeTime*alpha, alpha, 0)
end


--Main
Minimap:HookScript("OnEnter", function() DaftFade:FadeIn(self.GetName()) end)
Minimap:HookScript("OnLeave", function() DaftFade:FadeOut(self.GetName()) end)

Thanks for your time!

[semlar]

If you're indoors you can't alter the opacity of the minimap, and even if you're outdoors it doesn't change the opacity of the tracking dots, it only fades the background.

Even if you could fade the minimap, your code has a few issues; I would just rewrite it like this..

local fadeTime = 0.5     -- fade time in seconds
Minimap:SetAlpha(0) -- default opacity of 0
Minimap:HookScript("OnEnter", function()
    local alpha = Minimap:GetAlpha()
    UIFrameFadeIn(Minimap, fadeTime * (1 - alpha), alpha, 1)
end)
 
Minimap:HookScript("OnLeave", function()
    local alpha = Minimap:GetAlpha()
    UIFrameFadeOut(Minimap, fadeTime * alpha, alpha, 0)
end)

[tonyis3l33t]

Thanks semlar. I So in my code the issue might be calling a nil value when trying to get the alpha?

While I appreciate the rewrite, I have it this way because I'm trying to expand the fading to other frames later. Any tips on my crappy code, especially glaring issues?

[MunkDev]

Just wanted to drop by and mention that UIFrameFadeIn can potentially spread execution taint, since it's used by some of the protected code in the standard UI. I investigated this a long time ago, since I ran into it without a clue what was causing it. I believe there might even be a post about the issue on these forums.

I suggest using a custom animation manager instead, which removes any chance of spreading taint. This code is 95% stolen from someone else (can't remember who), but it does the trick. You can include this "file" as is in your toc, then grab the functions from your addon table, which also solves the issue of reuseability since you can reach it from any file in your addon.

---------------------------------------------------------------
-- Animation.lua: Taint-free animation replacement
---------------------------------------------------------------
-- Provides a replacement for managing alpha animations without
-- risk of spreading taint, which might happen when the "real"
-- functions are called from secure code.
 
local _, db = ...
 
---------------------------------------------------------------
-- Fade: Taint-free fade functions
---------------------------------------------------------------
 
local FADEFRAMES = {}
local FadeManager = CreateFrame("Frame")
 
local function FadeRemoveFrame(frame)
    tDeleteItem(FADEFRAMES, frame)
end
 
local function FadeOnUpdate(self, elapsed)
    local index = 1
    local frame, fadeInfo
    while FADEFRAMES[index] do
        frame = FADEFRAMES[index]
        fadeInfo = FADEFRAMES[index].fadeInfo
        -- Reset the timer if there isn't one, this is just an internal counter
        if ( not fadeInfo.fadeTimer ) then
            fadeInfo.fadeTimer = 0
        end
        fadeInfo.fadeTimer = fadeInfo.fadeTimer + elapsed
 
        -- If the fadeTimer is less then the desired fade time then set the alpha otherwise hold the fade state, call the finished function, or just finish the fade 
        if fadeInfo.fadeTimer < fadeInfo.timeToFade then
            if fadeInfo.mode == "IN" then
                frame:SetAlpha((fadeInfo.fadeTimer / fadeInfo.timeToFade) * (fadeInfo.endAlpha - fadeInfo.startAlpha) + fadeInfo.startAlpha)
            elseif fadeInfo.mode == "OUT" then
                frame:SetAlpha(((fadeInfo.timeToFade - fadeInfo.fadeTimer) / fadeInfo.timeToFade) * (fadeInfo.startAlpha - fadeInfo.endAlpha)  + fadeInfo.endAlpha)
            end
        else
            frame:SetAlpha(fadeInfo.endAlpha)
            -- If there is a fadeHoldTime then wait until its passed to continue on
            if fadeInfo.fadeHoldTime and fadeInfo.fadeHoldTime > 0  then
                fadeInfo.fadeHoldTime = fadeInfo.fadeHoldTime - elapsed
            else
                -- Complete the fade and call the finished function if there is one
                FadeRemoveFrame(frame)
                if fadeInfo.finishedFunc then
                    fadeInfo.finishedFunc(fadeInfo.finishedArg1, fadeInfo.finishedArg2, fadeInfo.finishedArg3, fadeInfo.finishedArg4)
                    fadeInfo.finishedFunc = nil
                end
            end
        end
        
        index = index + 1
    end
    
    if #FADEFRAMES == 0 then
        self:SetScript("OnUpdate", nil)
    end
end
 
-- Generic fade function
local function FadeFrame(frame, fadeInfo)
    if not frame then
        return
    end
    if not fadeInfo.mode then
        fadeInfo.mode = "IN"
    end
    local alpha
    if fadeInfo.mode == "IN" then
        if not fadeInfo.startAlpha then
            fadeInfo.startAlpha = 0
        end
        if not fadeInfo.endAlpha then
            fadeInfo.endAlpha = 1.0
        end
        alpha = 0
    elseif fadeInfo.mode == "OUT" then
        if not fadeInfo.startAlpha then
            fadeInfo.startAlpha = 1.0
        end
        if not fadeInfo.endAlpha then
            fadeInfo.endAlpha = 0
        end
        alpha = 1.0
    end
    frame:SetAlpha(fadeInfo.startAlpha)
 
    frame.fadeInfo = fadeInfo
 
    local index = 1
    while FADEFRAMES[index] do
        -- If frame is already set to fade then return
        if FADEFRAMES[index] == frame then
            return
        end
        index = index + 1
    end
    tinsert(FADEFRAMES, frame)
    FadeManager:SetScript("OnUpdate", FadeOnUpdate)
end
 
-- Convenience function for simple fade in
db.UIFrameFadeIn = function (frame, timeToFade, startAlpha, endAlpha)
    local fadeInfo = {}
    fadeInfo.mode = "IN"
    fadeInfo.timeToFade = timeToFade
    fadeInfo.startAlpha = startAlpha
    fadeInfo.endAlpha = endAlpha
    FadeFrame(frame, fadeInfo)
end
 
-- Convenience function for simple fade out
db.UIFrameFadeOut = function (frame, timeToFade, startAlpha, endAlpha)
    local fadeInfo = {}
    fadeInfo.mode = "OUT"
    fadeInfo.timeToFade = timeToFade
    fadeInfo.startAlpha = startAlpha
    fadeInfo.endAlpha = endAlpha
    FadeFrame(frame, fadeInfo)
end
 
 
---------------------------------------------------------------
-- Flash: Taint-free flash functions
---------------------------------------------------------------
local FlashManager = CreateFrame("FRAME")
local FLASHFRAMES = {}
 
local FlashTimers = {}
local FlashTimerRefCount = {}
 
-- Function to stop flashing
local function FlashStop(frame)
    tDeleteItem(FLASHFRAMES, frame)
    frame:SetAlpha(1.0)
    frame.flashTimer = nil
    if frame.syncId then
        FlashTimerRefCount[frame.syncId] = FlashTimerRefCount[frame.syncId]-1
        if FlashTimerRefCount[frame.syncId] == 0 then
            FlashTimers[frame.syncId] = nil
            FlashTimerRefCount[frame.syncId] = nil
        end
        frame.syncId = nil
    end
    if frame.showWhenDone then
        frame:Show()
    else
        frame:Hide()
    end
end
 
-- Called every frame to update flashing frames
local function FlashOnUpdate(self, elapsed)
    local frame
    local index = #FLASHFRAMES
    
    -- Update timers for all synced frames
    for syncId, timer in pairs(FlashTimers) do
        FlashTimers[syncId] = timer + elapsed
    end
    
    while FLASHFRAMES[index] do
        frame = FLASHFRAMES[index]
        frame.flashTimer = frame.flashTimer + elapsed
 
        if (frame.flashTimer > frame.flashDuration) and frame.flashDuration ~= -1 then
            FlashStop(frame)
        else
            local flashTime = frame.flashTimer
            local alpha
            
            if frame.syncId then
                flashTime = FlashTimers[frame.syncId]
            end
            
            flashTime = flashTime%(frame.fadeInTime+frame.fadeOutTime+(frame.flashInHoldTime or 0)+(frame.flashOutHoldTime or 0))
            if flashTime < frame.fadeInTime then
                alpha = flashTime/frame.fadeInTime
            elseif flashTime < frame.fadeInTime+(frame.flashInHoldTime or 0) then
                alpha = 1
            elseif flashTime < frame.fadeInTime+(frame.flashInHoldTime or 0)+frame.fadeOutTime then
                alpha = 1 - ((flashTime - frame.fadeInTime - (frame.flashInHoldTime or 0))/frame.fadeOutTime)
            else
                alpha = 0
            end
            
            frame:SetAlpha(alpha)
            frame:Show()
        end
        
        -- Loop in reverse so that removing frames is safe
        index = index - 1
    end
    
    if #FLASHFRAMES == 0 then
        self:SetScript("OnUpdate", nil)
    end
end
 
-- Function to start a frame flashing
db.UIFrameFlash =  function(frame, fadeInTime, fadeOutTime, flashDuration, showWhenDone, flashInHoldTime, flashOutHoldTime, syncId)
    if frame then
        local index = 1
        -- If frame is already set to flash then return
        while FLASHFRAMES[index] do
            if FLASHFRAMES[index] == frame then
                return
            end
            index = index + 1
        end
 
        if syncId then
            frame.syncId = syncId
            if FlashTimers[syncId] == nil then
                FlashTimers[syncId] = 0
                FlashTimerRefCount[syncId] = 0
            end
            FlashTimerRefCount[syncId] = FlashTimerRefCount[syncId]+1
        else
            frame.syncId = nil
        end
        
        -- Time it takes to fade in a flashing frame
        frame.fadeInTime = fadeInTime
        -- Time it takes to fade out a flashing frame
        frame.fadeOutTime = fadeOutTime
        -- How long to keep the frame flashing
        frame.flashDuration = flashDuration
        -- Show the flashing frame when the fadeOutTime has passed
        frame.showWhenDone = showWhenDone
        -- Internal timer
        frame.flashTimer = 0
        -- How long to hold the faded in state
        frame.flashInHoldTime = flashInHoldTime
        -- How long to hold the faded out state
        frame.flashOutHoldTime = flashOutHoldTime
        
        tinsert(FLASHFRAMES, frame)
        
        FlashManager:SetScript("OnUpdate", FlashOnUpdate)
    end
end

[tonyis3l33t]

Hey, thanks MunkDev for the sample code

So I troubleshot this a bit tonight just to learn from what I did wrong. Found my mistake:

Minimap:HookScript("OnEnter", function() DaftFade:FadeIn(self.GetName()) end)

the self.GetName() isn't working here. If I replace it with "Minimap" it works fine.

[Fizzlemizz]

If you changed:

Minimap:HookScript("OnEnter", function() DaftFade:FadeIn(self.GetName()) end)

to:

Minimap:HookScript("OnEnter", function(self) DaftFade:FadeIn(self.GetName()) end)

But either way is essentially the same thing.

[MunkDev]

First of all, you should pass the frame itself to your function wrapper, not the name of the frame. Secondly, calling a function like this:

self.GetName()

...doesn't pass any frame into the GetName function. For future reference, you'll want to do this:

self:GetName()

https://coronalabs.com/blog/2015/12/...-dot-operator/

Try this:

Minimap:HookScript("OnEnter", function(self) DaftFade:FadeIn(self) end)

[tonyis3l33t]

So i spent many hours over the past week and ended up with this! My code is getting a little better as I gain experience, as expected. Thanks everyone for your insights.

http://www.wowinterface.com/download...-DaftFade.html