Frames: XML vs LUA?

[Sweetsour]

So far in my addon, I've created all my frame/UI elements using LUA. I've been wondering, is there a substantial difference with using XML over LUA? I've read that XML might be faster, but haven't found any confirmation of this. Anyone know?

[Malakahh]

The most substantial thing I'm aware of, is that XML is required if you wish to CREATE templates. You can still use templates through lua. Other than that, I don't believe there's much difference.

Lua isn't an acronym btw, it means moon. :P

[Fizzlemizz]

XML is only required if you want to use the secure templates, other than that lua works fine and is easier to debug if nothing else.

You can mimic templates in lua.

[Banknorris]

Quoting someone I consider a WoW guru (Gello), if not that, at least he spent a lot of time teaching coding to people interested in learning:

XML is more optimized to load/create frames and their attributes, and has some tags like forceAlpha that would be more cumbersome/inefficient to do in lua. Some XML is required if you ever make a hybrid scrollframe. Element stacking is much easier in XML too; not just from the nature of the code but tags like useParentLevel and textureSubLevel allow you to define how your stuff layers without micromanaging every detail or creating unnecessary frames. XML also has some recent tags like parentArray that makes it easy to reference all your stuff in lua too. But lua-only addons are perfectly acceptable too. It's not more "efficient" to do it one way or the other once your stuff actually loads. For smaller projects (or even bigger ones without many UI elements), I'll usually do everything in lua. For bigger projects with many UI elements, XML is my personal preference.

[Sweetsour]

Thanks for the info guys!

[Torhal]

Originally Posted by Banknorris Quoting someone I consider a WoW guru (Gello), if not that, at least he spent a lot of time teaching coding to people interested in learning:

I've made a HybridScrollFrame without using XML...

[Lombra]

I like the concept behind using XML for frames, in that the language format is structured to actually represent the logical structure of the elements, and that it clearly separates elements from function. (subject to major abuse of technical terms) But! It simply requires too much effort to get things done compared to doing it in Lua.

I started working on some code that would essentially let you replace XML templates with Lua tables, but was not sure whether it'd be worth it in the end.

[kurapica.igas]

All can be done in lua, include the elements that based on secure templates. But it also requires plenty of works to build a whole framework instead of the xml template system.

Here is an example lib IGAS, it's created without xml templates, it's based on an oop system(PLoop) so I can make widget classes instead of the xml template. There are widget classes such as TreeView, LayoutPanel, CodeEditor, UnitFrame, UnitPanel(as the raid panel), ActionButton and many others, all be created based on other widget classes.

With the class system, the code will be clear for reading. To create a form in the pic :

-- Import the namespace
import "System.Widget" 
 
-- Form is a class that defined in the System.Widget namespace
-- It's a common widget element that used to contains others
local form = Form ("TestF")
-- Caption is the text that displayed on the form header
form.Caption = "Tiny Editor"
-- Message is the text that displayed on the bottom of the form
form.Message = "Input some code and press run"
form.Size = Size(600, 500)
 
-- lua code editor
local editor = CodeEditor ("Editor", form)
editor.Location = {
  AnchorPoint("TOPLEFT", 4, -26), 
  AnchorPoint("BOTTOMRIGHT", -4, 56), 
}
 
-- the run button
local btn = NormalButton ("Run", form)
btn.Style = "Classic"
btn.Size = Size(100, 24)
btn.Text = "Run"
btn.Location = {
  AnchorPoint("BOTTOMRIGHT", -4, 24),
}
 
-- Run the code when click the button
function btn:OnClick()
  pcall( loadstring (editor.Text) )
end

With the oop system, I also can define a whole new class for the above example:

-- Import the System.Widget namespace
import "System.Widget" 
 
-- Create a new class that inherit from the Form
class "CodeForm"
  inherit "Form"
 
  local function run_OnClick(self)
    pcall( loadstring (self.Parent.Editor.Text) )
  end
 
  -- Init the CodeForm
  local function InitializeComponent(self)    
    self.Caption = "Tiny Editor"
    self.Message = "Input some code and press run"
    self.Size = Size(600, 500)
 
    -- lua code editor
    local editor = CodeEditor ("Editor", self)
    editor.Location = {
      AnchorPoint("TOPLEFT", 4, -26), 
      AnchorPoint("BOTTOMRIGHT", -4, 56), 
    }
 
    -- the run button
    local btn = NormalButton ("Run", self)
    btn.Style = "Classic"
    btn.Size = Size(100, 24)
    btn.Text = "Run"
    btn.Location = {
      AnchorPoint("BOTTOMRIGHT", -4, 24),
    }
 
    btn.OnClick = btn.OnClick + run_OnClick
  end
 
  -- The Constructor
  function CodeForm(self, ...)
    -- call super class's constructor
    Super(self, ...)
 
    InitializeComponent(self)
  end
-- End the definition of the class
endclass "CodeForm"
 
-- Create an instance of the CodeForm
local form = CodeForm("TestForm")
-- make sure the form is shown
form.Visible = true

It may not be a good example because the whole IGAS lib is a big one and the syntax of the PLoop is too special for common addons.

The xml is not that bad, it's very clear to show the structure of the whole frames, but it's not good at the inheritance. Here is some from the MainMenuBarBagButtons.xml.

	<Frame name="ItemAnimTemplate" virtual="true">
                 <Scripts>
			<OnLoad function="ItemAnim_OnLoad"/>
			<OnEvent function="ItemAnim_OnEvent"/>
		</Scripts>
        </Frame>

         <CheckButton name="BagSlotButtonTemplate" inherits="ItemButtonTemplate, ItemAnimTemplate" virtual="true">
		<Size x="30" y="30"/>
		<Scripts>
			<OnLoad>
				ItemAnim_OnLoad(self)
				PaperDollItemSlotButton_OnLoad(self);
                .......

So the BagSlotButtonTemplate should call ItemAnim_OnLoad itself, that means the child template must know what the super template had done.

It's not a big problem, but I just don't like it.

[Duugu]

I hate XML because of its poor "debugging capabilities".

[Malsomnus]

Personally, I prefer lua, because:
a) While I haven't touched these XMLs in some time, I remember everything having to be enclosed with <Points></Points> and then inside it every element is <Point>...</Point>. That's a lot of text that I'd rather live without.
b) Representing your frames as being inside one another is all good and fine, but I like having all the important init details of a frame in one place, rather than having to scroll a thousand lines between its size and its backdrop because there is literally an entire add-on's frame structure stuck between them.
c) Templates are good and fine, but I prefer functions
d) Debugging...