Blizz metamethods

[Aanson]

Hey all,

How can I get a reference to the metatable which is used by all frames created ingame ( which contains Show, SetClampedToScreen, IsObjectType etc etc )?

Only reason I ask is because I wouldn't mind adding a few of my own methods.

If I can't do that, I'll just add the methods to each frame directly, but it seems daft having to replicate them each time.

Cheers for any advice.

[Lombra]

local metatable = getmetatable(CreateFrame("Frame"))

Note that each object type (Frame, Button, Slider, etc) has its own metatable.

[Phanx]

That said, there's really no reason to meddle with the Blizzard metatable. It's absolutely trivial to add methods to a frame, and you don't have to "replicate" anything; definte each method once, and just add a pointer to each frame as desired:

local function DoSomething(frame)
    -- do something with the frame
end

for i = 1, 100000 do
    _G["MyButton"..i].DoSomething = DoSomething
end

Obviously you don't (I hope) have 100000 buttons, but the principle is the same. It doesn't matter how many frames you attach the function to; only one copy of the function exists.

[Aanson]

Originally Posted by Phanx That said, there's really no reason to meddle with the Blizzard metatable. It's absolutely trivial to add methods to a frame, and you don't have to "replicate" anything; definte each method once, and just add a pointer to each frame as desired: local function DoSomething(frame) -- do something with the frame end for i = 1, 100000 do _G["MyButton"..i].DoSomething = DoSomething end Obviously you don't (I hope) have 100000 buttons, but the principle is the same. It doesn't matter how many frames you attach the function to; only one copy of the function exists.

In the above example, the function is replicated and _G["MyButton"..i].DoSomething is not a pointer to the locally defined function 'DoSomething', it's a separate copy of the function. That's what I had meant by 'replicate'.

I confirmed this with the following test...

local self = CreateFrame();
 
local function TestFunction()
  print("Hello");
end
 
self.TestFunction = TestFunction;
 
self:TestFunction(); -- obviously results in output: "Hello";

if you then change the locally defined function to print("Goodbye") and call self:TestFunction() again, it'll still output "Hello".


Regardless, I've added the methods to the frames directly anyway, although I see no harm what-so-ever in 'meddling' with (ie adding methods to) Blizz's table.

[jeruku]

Perhaps you should use a function to add functions to frames.

For example:

end
local function DoSomething(self, ...)
   print("Hello")
end
local function DoALittleDance(self, ...)
   print("Bonjour")
end
local function NowDoAHandStand(self, ...)
   print("Aloha")
end
local function AddFunctionsToFrame(self)
     self.func1 = DoSomething
     self.func2 = DoALittleDance
     self.func3 = NowDoAHandStand
end
 
local frame = CreateFrame('Frame')
local frame2 = CreateFrame('Frame')
 
AddFunctionsToFrame(frame)
AddFunctionsToFrame(frame2)

Seeing as you were playing with code here is an example you may have missed.

local frame = CreateFrame()
 
local function TestFunction()
  print("Hello")
end
print(TestFunction) -- prints the function identifier
 
frame.aFunc= TestFunction
print(frame.aFunc) 
 
frame:aFunc()
TestFunction = function()
  print("Goodbye")
end
 
print(TestFunction)
print(frame.aFunc) -- This will print the identifier of the original function

[semlar]

Originally Posted by Aanson In the above example, the function is replicated and _G["MyButton"..i].DoSomething is not a pointer to the locally defined function 'DoSomething', it's a separate copy of the function.

This is not correct. You can compare self.TestFunction == TestFunction in your example to see that they are references to the same function.

It sounds to me like however you were redefining the function in your test was creating a new instance of it.

[ravagernl]

ElvUI an Tukui define a "toolkit" using metamethods, i'm however not going to link or share any code because of license issues. LibCandybar also uses a metatable to add functions to a private frametype.

There is also a thread dated from 2014 on wowace.com about metamethods, one of them has an excellent example.

[Duugu]

There's another possible way to add something as default to widgets: the XML templates.
Like this:

<Frame name="myTest" virtual="true">
        <Scripts>
            <OnLoad>
                self.print = function(...) print("it's me, the myTest template") end
            </OnLoad>
        </Scripts>
</Frame>    

local myTestFrame = CreateFrame("Frame", "myFrame", UIParent, "myTest")
myTestFrame:print()

It's not that elegant as it requires XML and code editing inside XML, but it's easy to use.

[Aanson]

Thanks everyone for your advice.

Originally Posted by semlar This is not correct. You can compare self.TestFunction == TestFunction in your example to see that they are references to the same function. It sounds to me like however you were redefining the function in your test was creating a new instance of it.

Yeah Semlar, I noticed that too after I'd written that post...

local function func() end
local self = CreateFrame();
self.func = func;
print( self.func == func ); -- which returned true.

That would indicate that self.func and func both point to the same instance of the same function.

But it confuses me a little. Here's my example (and what made me think that it's actually a different instance of the same function:

local t, frame = {}, {};
function t.func()
  print("a");
end
 
frame.func = t.func;
 
frame:func() -- outputs 'a'
 
t.func = nil; -- the original function no longer exists
 
frame:func() -- still outputs 'a'

So surely frame.func doesn't simply point to t.func because if that were the case, it would return an error. Wouldn't that indicate that each frame the method is added to will hold it's own instance of that method?

Just to be clear, I'm not in any way trying to insist that what I'm saying is right... to be honest, I'm stumped.

I'd always thought that one of the primary benefits of a metatable is to allow numerous objects to refer to the same instance of a method, thereby conserving memory.

If I'm looking at this all wrong, please let me know.

[Aanson]

Originally Posted by ravagernl ElvUI an Tukui define a "toolkit" using metamethods, i'm however not going to link or share any code because of license issues. LibCandybar also uses a metatable to add functions to a private frametype. There is also a thread dated from 2014 on wowace.com about metamethods, one of them has an excellent example.

Special thanks for that

[Sharparam]

Originally Posted by Aanson t.func = nil; -- the original function no longer exists

This is not correct. By doing t.func = nil you are just making t.func no longer reference that function. Any other references to the function are still valid.

You are assigning nil to t.func, not assigning nil to the actual function stored in memory. Both t.func and frame.func are just pointers to that function.

(I could be wrong in any of my statements, someone please correct me in that case.)

Using a table as an example where you can see the change in both references (because tables are reference types in Lua):

local t = { foo = "bar" }
local a = { t = t }
local b = { t = t }
print(a.t.foo) -- prints "bar"
print(b.t.foo) -- prints "bar"
b.t.foo = "baz"
print(a.t.foo) -- prints "baz"

[Aanson]

Originally Posted by Sharparam This is not correct. By doing t.func = nil you are just making t.func no longer reference that function. Any other references to the function are still valid. You are assigning nil to t.func, not assigning nil to the actual function stored in memory. Both t.func and frame.func are just pointers to that function. (I could be wrong in any of my statements, someone please correct me in that case.) Using a table as an example where you can see the change in both references (because tables are reference types in Lua): local t = { foo = "bar" } local a = { t = t } local b = { t = t } print(a.t.foo) -- prints "bar" print(b.t.foo) -- prints "bar" b.t.foo = "baz" print(a.t.foo) -- prints "baz"

Ah okay.

Just to confirm my understanding. When I write...

t.func = nil;

... does lua check to see if the function is referenced by anything else. If it is, it keeps it, if not, it gets wiped from memory by the garbage collector?

[Sharparam]

Pretty sure that's how it works. The garbage collector goes through objects and disposes of any that don't have any variables referencing them.

[Aanson]

Originally Posted by Sharparam Pretty sure that's how it works. The garbage collector goes through objects and disposes of any that don't have any variables referencing them.

That clears things up. Cheers