Added proxy tables for the functions that returned dictionary-like collections.

Build/RocketLua.vcproj

@@ -294,6 +294,14 @@
 					RelativePath="..\Source\Controls\Lua\ElementFormControlTextArea.h"
 					>
 				</File>
+				<File
+					RelativePath="..\Source\Controls\Lua\SelectOptionsProxy.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\Source\Controls\Lua\SelectOptionsProxy.h"
+					>
+				</File>
 			</Filter>
 		</Filter>
 		<Filter
@@ -355,6 +363,14 @@
 				RelativePath="..\Source\Core\Lua\RocketLua.h"
 				>
 			</File>
+			<File
+				RelativePath="..\Source\Core\Lua\Utilities.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\Source\Core\Lua\Utilities.h"
+				>
+			</File>
 			<Filter
 				Name="Element"
 				>
@@ -366,6 +382,14 @@
 					RelativePath="..\Source\Core\Lua\Element.h"
 					>
 				</File>
+				<File
+					RelativePath="..\Source\Core\Lua\ElementAttributesProxy.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\Source\Core\Lua\ElementAttributesProxy.h"
+					>
+				</File>
 				<File
 					RelativePath="..\Source\Core\Lua\ElementStyle.cpp"
 					>
@@ -422,6 +446,14 @@
 					RelativePath="..\Source\Core\Lua\Event.h"
 					>
 				</File>
+				<File
+					RelativePath="..\Source\Core\Lua\EventParametersProxy.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\Source\Core\Lua\EventParametersProxy.h"
+					>
+				</File>
 				<File
 					RelativePath="..\Source\Core\Lua\LuaEventListener.cpp"
 					>

Source/Controls/Lua/ElementFormControlSelect.cpp

@@ -1,5 +1,6 @@
 #include "precompiled.h"
 #include "ElementFormControlSelect.h"
+#include "SelectOptionsProxy.h"
 #include <Rocket/Controls/ElementFormControlSelect.h>
 #include <Rocket/Controls/ElementFormControl.h>
 #include <Rocket/Core/Element.h>
@@ -51,30 +52,9 @@ int ElementFormControlSelectGetAttroptions(lua_State* L)
 {
     ElementFormControlSelect* obj = LuaType<ElementFormControlSelect>::check(L,1);
     LUACHECKOBJ(obj);
-    int numOptions = obj->GetNumOptions();
-
-    //local variables for the loop
-    Rocket::Controls::SelectOption* opt; 
-    Element* ele;
-    String value;
-    lua_newtable(L);
-    int retindex = lua_gettop(L);
-    for(int index = 0; index < numOptions; index++)
-    {
-        opt = obj->GetOption(index);
-        if(opt == NULL) continue;
-    
-        ele = opt->GetElement();
-        value = opt->GetValue();
-
-        lua_newtable(L);
-        LuaType<Element>::push(L,ele,false);
-        lua_setfield(L,-2,"element");
-        lua_pushstring(L,value.CString());
-        lua_setfield(L,-2,"value");
-        lua_rawseti(L,retindex,index); //sets the table that is being returned's 'index' to be the table with element and value
-        lua_pop(L,1); //pops the table with element,value from the stack
-    }
+    SelectOptionsProxy* proxy = new SelectOptionsProxy();
+    proxy->owner = obj;
+    LuaType<SelectOptionsProxy>::push(L,proxy,true);
     return 1;
 }
 

Source/Controls/Lua/SelectOptionsProxy.cpp

@@ -0,0 +1,77 @@
+#include "precompiled.h"
+#include "SelectOptionsProxy.h"
+#include <Rocket/Core/Element.h>
+
+namespace Rocket {
+namespace Core {
+namespace Lua {
+int SelectOptionsProxy__index(lua_State* L)
+{
+    /*the table obj and the missing key are currently on the stack(index 1 & 2) as defined by the Lua language*/
+    int keytype = lua_type(L,2);
+    if(keytype == LUA_TNUMBER) //only valid key types
+    {
+        SelectOptionsProxy* proxy = LuaType<SelectOptionsProxy>::check(L,1);
+        LUACHECKOBJ(proxy);
+        int index = luaL_checkint(L,2);
+        Rocket::Controls::SelectOption* opt = proxy->owner->GetOption(index);
+        LUACHECKOBJ(opt);
+        lua_newtable(L);
+        LuaType<Element>::push(L,opt->GetElement(),false);
+        lua_setfield(L,-2,"element");
+        lua_pushstring(L,opt->GetValue().CString());
+        lua_setfield(L,-2,"value");
+        return 1;
+    }
+    else
+        return LuaType<SelectOptionsProxy>::index(L);
+}
+
+//method
+int SelectOptionsProxyGetTable(lua_State* L, SelectOptionsProxy* obj)
+{
+    int numOptions = obj->owner->GetNumOptions();
+
+    //local variables for the loop
+    Rocket::Controls::SelectOption* opt; 
+    Element* ele;
+    String value;
+    lua_newtable(L); //table to return
+    int retindex = lua_gettop(L);
+    for(int index = 0; index < numOptions; index++)
+    {
+        opt = obj->owner->GetOption(index);
+        if(opt == NULL) continue;
+    
+        ele = opt->GetElement();
+        value = opt->GetValue();
+
+        lua_newtable(L);
+        LuaType<Element>::push(L,ele,false);
+        lua_setfield(L,-2,"element");
+        lua_pushstring(L,value.CString());
+        lua_setfield(L,-2,"value");
+        lua_rawseti(L,retindex,index); //sets the table that is being returned's 'index' to be the table with element and value
+    }
+    return 1;
+}
+
+RegType<SelectOptionsProxy> SelectOptionsProxyMethods[] =
+{
+    LUAMETHOD(SelectOptionsProxy,GetTable)
+    { NULL, NULL },
+};
+
+luaL_reg SelectOptionsProxyGetters[] =
+{
+    { NULL, NULL },
+};
+
+luaL_reg SelectOptionsProxySetters[] =
+{
+    { NULL, NULL },
+};
+
+}
+}
+}

Source/Controls/Lua/SelectOptionsProxy.h

@@ -0,0 +1,37 @@
+#pragma once
+/*
+    Proxy table for ElementFormControlSelect.options
+    read-only, key must be a number
+    Each object in this proxy is a table with two items:
+    Element element and String value
+    Usage:
+    ElementFormControlSelect.options[2].element or ElementFormControlSelect.options[2].value
+    OR, as usual you can store the object in a variable like
+    local opt = ElementFormControlSelect.options
+    opt[2].element or opt[2].value
+    and you can store the returned table as a variable, of course
+    local item = opt[2]
+    item.element or item.value
+*/
+#include <Rocket/Core/Lua/lua.hpp>
+#include <Rocket/Core/Lua/LuaType.h>
+#include <Rocket/Controls/ElementFormControlSelect.h>
+
+namespace Rocket {
+namespace Core {
+namespace Lua {
+//where owner is the ElementFormControlSelect that we should look up information from
+struct SelectOptionsProxy { Rocket::Controls::ElementFormControlSelect* owner;  };
+
+template<> void LuaType<SelectOptionsProxy>::extra_init(lua_State* L, int metatable_index);
+int SelectOptionsProxy__index(lua_State* L);
+
+//method
+int SelectOptionsProxyGetTable(lua_State* L, SelectOptionsProxy* obj);
+
+RegType<SelectOptionsProxy> SelectOptionsProxyMethods[];
+luaL_reg SelectOptionsProxyGetters[];
+luaL_reg SelectOptionsProxySetters[];
+}
+}
+}

Source/Core/Lua/Element.cpp

@@ -2,6 +2,8 @@
 #include "Element.h"
 #include <ElementStyle.h>
 #include "LuaEventListener.h"
+#include "ElementAttributesProxy.h"
+#include "Utilities.h"
 
 
 namespace Rocket {
@@ -105,37 +107,7 @@ int ElementGetAttribute(lua_State* L, Element* obj)
 {
     const char* name = luaL_checkstring(L,1);
     Variant* var = obj->GetAttribute(name);
-    Variant::Type type = var->GetType();
-    switch(type)
-    {
-    case Variant::BYTE:
-    case Variant::CHAR:
-    case Variant::INT:
-        lua_pushinteger(L,var->Get<int>());
-        break;
-    case Variant::FLOAT:
-        lua_pushnumber(L,var->Get<float>());
-        break;
-    case Variant::COLOURB:
-        LuaType<Colourb>::push(L,&var->Get<Colourb>(),false);
-        break;
-    case Variant::COLOURF:
-        LuaType<Colourf>::push(L,&var->Get<Colourf>(),false);
-        break;
-    case Variant::STRING:
-        lua_pushstring(L,var->Get<String>().CString());
-        break;
-    case Variant::VECTOR2:
-        //according to Variant.inl, it is going to be a Vector2f
-        LuaType<Vector2f>::push(L,&var->Get<Vector2f>(),false);
-        break;
-    case Variant::VOIDPTR:
-        lua_pushlightuserdata(L,var->Get<void*>());
-        break;
-    default:
-        lua_pushnil(L);
-        break;
-    }
+    PushVariant(L,var);
     return 1;
 }
 
@@ -273,50 +245,9 @@ int ElementGetAttrattributes(lua_State* L)
 {
     Element* ele = LuaType<Element>::check(L,1);
     LUACHECKOBJ(ele);
-    
-    int index;
-    String key;
-    Variant* var;
-    Variant::Type type;
-
-    lua_newtable(L);
-    while(ele->IterateAttributes(index,key,var))
-    {
-        lua_pushstring(L,key.CString());
-        type = var->GetType();
-        switch(type)
-        {
-        case Variant::BYTE:
-        case Variant::CHAR:
-        case Variant::INT:
-            lua_pushinteger(L,var->Get<int>());
-            break;
-        case Variant::FLOAT:
-            lua_pushnumber(L,var->Get<float>());
-            break;
-        case Variant::COLOURB:
-            LuaType<Colourb>::push(L,&var->Get<Colourb>(),false);
-            break;
-        case Variant::COLOURF:
-            LuaType<Colourf>::push(L,&var->Get<Colourf>(),false);
-            break;
-        case Variant::STRING:
-            lua_pushstring(L,var->Get<String>().CString());
-            break;
-        case Variant::VECTOR2:
-            //according to Variant.inl, it is going to be a Vector2f
-            LuaType<Vector2f>::push(L,&var->Get<Vector2f>(),false);
-            break;
-        case Variant::VOIDPTR:
-            lua_pushlightuserdata(L,var->Get<void*>());
-            break;
-        default:
-            lua_pushnil(L);
-            break;
-        }   
-        lua_settable(L,-3);
-    }
-    
+    ElementAttributesProxy* proxy = new ElementAttributesProxy();
+    proxy->owner = ele;
+    LuaType<ElementAttributesProxy>::push(L,proxy,true);    
     return 1;
 }
 

Source/Core/Lua/ElementAttributesProxy.cpp

@@ -0,0 +1,60 @@
+#include "precompiled.h"
+#include "ElementAttributesProxy.h"
+#include <Rocket/Core/Variant.h>
+#include "Utilities.h"
+
+namespace Rocket {
+namespace Core {
+namespace Lua {
+int ElementAttributesProxy__index(lua_State* L)
+{
+    /*the table obj and the missing key are currently on the stack(index 1 & 2) as defined by the Lua language*/
+    int keytype = lua_type(L,2);
+    if(keytype == LUA_TSTRING) //only valid key types
+    {
+        ElementAttributesProxy* obj = LuaType<ElementAttributesProxy>::check(L,1);
+        LUACHECKOBJ(obj);
+        const char* key = lua_tostring(L,2);
+        Variant* attr = obj->owner->GetAttribute(key);
+        PushVariant(L,attr); //Utilities.h
+        return 1;
+    }
+    else
+        return LuaType<ElementAttributesProxy>::index(L);
+}
+
+//method
+int ElementAttributesProxyGetTable(lua_State* L, ElementAttributesProxy* obj)
+{    
+    int index;
+    String key;
+    Variant* var;
+
+    lua_newtable(L);
+    int tbl = lua_gettop(L);
+    while(obj->owner->IterateAttributes(index,key,var))
+    {
+        lua_pushstring(L,key.CString());
+        PushVariant(L,var);
+        lua_settable(L,tbl);
+    }
+    return 1;
+}
+
+RegType<ElementAttributesProxy> ElementAttributesProxyMethods[] =
+{
+    LUAMETHOD(ElementAttributesProxy,GetTable)
+    { NULL, NULL },
+};
+
+luaL_reg ElementAttributesProxyGetters[] =
+{
+    { NULL, NULL },
+};
+luaL_reg ElementAttributesProxySetters[] =
+{
+    { NULL, NULL },
+};
+}
+}
+}

Source/Core/Lua/ElementAttributesProxy.h

@@ -0,0 +1,27 @@
+#pragma once
+/*
+    Proxy table for Element.attribues
+    read-only Dictionary
+*/
+#include <Rocket/Core/Lua/lua.hpp>
+#include <Rocket/Core/Lua/LuaType.h>
+#include <Rocket/Core/Element.h>
+
+namespace Rocket {
+namespace Core {
+namespace Lua {
+//where owner is the Element that we should look up information from
+struct ElementAttributesProxy { Element* owner;  };
+
+template<> void LuaType<ElementAttributesProxy>::extra_init(lua_State* L, int metatable_index);
+int ElementAttributesProxy__index(lua_State* L);
+
+//method
+int ElementAttributesProxyGetTable(lua_State* L, ElementAttributesProxy* obj);
+
+RegType<ElementAttributesProxy> ElementAttributesProxyMethods[];
+luaL_reg ElementAttributesProxyGetters[];
+luaL_reg ElementAttributesProxySetters[];
+}
+}
+}

Source/Core/Lua/Event.cpp

@@ -4,6 +4,7 @@
 #include <Rocket/Core/Event.h>
 #include <Rocket/Core/Element.h>
 #include <Rocket/Core/Dictionary.h>
+#include "EventParametersProxy.h"
 
 
 namespace Rocket {
@@ -49,101 +50,12 @@ int EventGetAttrparameters(lua_State* L)
 {
     Event* evt = LuaType<Event>::check(L,1);
     LUACHECKOBJ(evt);
-    const Dictionary* params = evt->GetParameters();
-    int index = 0;
-    String key;
-    Variant* value;
-
-    lua_newtable(L);
-    int tableindex = lua_gettop(L);
-    while(params->Iterate(index,key,value))
-    {
-        lua_pushstring(L,key.CString());
-        Variant::Type type = value->GetType();
-        switch(type)
-        {
-        case Variant::BYTE:
-        case Variant::CHAR:
-        case Variant::INT:
-            lua_pushinteger(L,value->Get<int>());
-            break;
-        case Variant::FLOAT:
-            lua_pushnumber(L,value->Get<float>());
-            break;
-        case Variant::COLOURB:
-            LuaType<Colourb>::push(L,&value->Get<Colourb>(),false);
-            break;
-        case Variant::COLOURF:
-            LuaType<Colourf>::push(L,&value->Get<Colourf>(),false);
-            break;
-        case Variant::STRING:
-            lua_pushstring(L,value->Get<String>().CString());
-            break;
-        case Variant::VECTOR2:
-            //according to Variant.inl, it is going to be a Vector2f
-            LuaType<Vector2f>::push(L,&value->Get<Vector2f>(),false);
-            break;
-        case Variant::VOIDPTR:
-            lua_pushlightuserdata(L,value->Get<void*>());
-            break;
-        default:
-            lua_pushnil(L);
-            break;
-        }
-        lua_settable(L,tableindex);
-    }
+    EventParametersProxy* proxy = new EventParametersProxy();
+    proxy->owner = evt;
+    LuaType<EventParametersProxy>::push(L,proxy,true);
     return 1;
 }
 
-
-
-//setters
-/*
-//Apparently, the dictionary returned is constant, and shouldn't be modified.
-//I am keeping this function in case that isn't the case
-int EventSetAttrparameters(lua_State* L)
-{
-    Event* evt = LuaType<Event>::check(L,1);
-    LUACHECKOBJ(evt);
-    const Dictionary* params = evt->GetParameters();
-    int valtype = lua_type(L,2);
-    if(valtype == LUA_TTABLE) //if the user gives a table, then go through the table and set everything
-    {
-        lua_pushnil(L); //becauase lua_next pops a key from the stack first, we don't want to pop the table
-        while(lua_next(L,2) != 0)
-        {
-            //[-1] is value, [-2] is key
-            int type = lua_type(L,-1);
-            const char* key = luaL_checkstring(L,-2); //key HAS to be a string, or things will go bad
-            switch(type)
-            {
-		    case LUA_TNUMBER:
-                params->Set(key,(float)lua_tonumber(L,-1));
-                break;
-		    case LUA_TBOOLEAN: 
-                params->Set(key,CHECK_BOOL(L,-1));
-                break;
-		    case LUA_TSTRING:
-                params->Set(key,luaL_checkstring(L,-1));
-                break;
-            case LUA_TUSERDATA:
-            case LUA_TLIGHTUSERDATA:
-                params->Set(key,lua_touserdata(L,-1));
-                break;
-            default:
-                break;
-            }
-        }
-    }
-    else if(valtype == LUA_TNIL)
-    {
-        params->Clear();
-    }
-    return 0;
-}
-*/
-
-
 RegType<Event> EventMethods[] =
 {
     LUAMETHOD(Event,StopPropagation)
@@ -161,7 +73,6 @@ luaL_reg EventGetters[] =
 
 luaL_reg EventSetters[] =
 {
-    //LUASETTER(Event,parameters)
     { NULL, NULL },
 };
 

Source/Core/Lua/Event.h

@@ -31,9 +31,6 @@ int EventGetAttrtype(lua_State* L);
 int EventGetAttrtarget_element(lua_State* L);
 int EventGetAttrparameters(lua_State* L);
 
-//setters
-//int EventSetAttrparameters(lua_State* L);
-
 RegType<Event> EventMethods[];
 luaL_reg EventGetters[];
 luaL_reg EventSetters[];

Source/Core/Lua/EventParametersProxy.cpp

@@ -0,0 +1,62 @@
+#include "precompiled.h"
+#include "EventParametersProxy.h"
+#include "Utilities.h"
+#include <Rocket/Core/Variant.h>
+#include <Rocket/Core/Dictionary.h>
+
+
+namespace Rocket {
+namespace Core {
+namespace Lua {
+int EventParametersProxy__index(lua_State* L)
+{
+    /*the table obj and the missing key are currently on the stack(index 1 & 2) as defined by the Lua language*/
+    int keytype = lua_type(L,2);
+    if(keytype == LUA_TSTRING) //only valid key types
+    {
+        EventParametersProxy* obj = LuaType<EventParametersProxy>::check(L,1);
+        LUACHECKOBJ(obj);
+        const char* key = lua_tostring(L,2);
+        Variant* param = obj->owner->GetParameters()->Get(key);
+        PushVariant(L,param);
+        return 1;
+    }
+    else
+        return LuaType<EventParametersProxy>::index(L);
+}
+
+//method
+int EventParametersProxyGetTable(lua_State* L, EventParametersProxy* obj)
+{
+    const Dictionary* params = obj->owner->GetParameters();
+    int index = 0;
+    String key;
+    Variant* value;
+
+    lua_newtable(L);
+    int tableindex = lua_gettop(L);
+    while(params->Iterate(index,key,value))
+    {
+        lua_pushstring(L,key.CString());
+        PushVariant(L,value);
+        lua_settable(L,tableindex);
+    }
+    return 1;
+}
+
+RegType<EventParametersProxy> EventParametersProxyMethods[] =
+{
+    LUAMETHOD(EventParametersProxy,GetTable)
+    { NULL, NULL },
+};
+luaL_reg EventParametersProxyGetters[] =
+{
+    { NULL, NULL },
+};
+luaL_reg EventParametersProxySetters[] =
+{
+    { NULL, NULL },
+};
+}
+}
+}

Source/Core/Lua/EventParametersProxy.h

@@ -0,0 +1,27 @@
+#pragma once
+/*
+    Proxy table for Event.parameters
+    read-only Dictionary
+*/
+#include <Rocket/Core/Lua/lua.hpp>
+#include <Rocket/Core/Lua/LuaType.h>
+#include <Rocket/Core/Event.h>
+
+namespace Rocket {
+namespace Core {
+namespace Lua {
+//where owner is the Element that we should look up information from
+struct EventParametersProxy { Event* owner;  };
+
+template<> void LuaType<EventParametersProxy>::extra_init(lua_State* L, int metatable_index);
+int EventParametersProxy__index(lua_State* L);
+
+//method
+int EventParametersProxyGetTable(lua_State* L, EventParametersProxy* obj);
+
+RegType<EventParametersProxy> EventParametersProxyMethods[];
+luaL_reg EventParametersProxyGetters[];
+luaL_reg EventParametersProxySetters[];
+}
+}
+}

Source/Core/Lua/LuaTypeTemplateSpec.inl

@@ -1,6 +1,6 @@
 /*
     Because all of the template specializations have to be compiled in the same translation unit, they have to 
-    exist in this file. It is included by LuaType.cpp
+    exist in this file. It is included by LuaType.cpp (or LuaType.inl right now)
 */
 #include "precompiled.h"
 #include <Rocket/Core/Core.h>
@@ -30,6 +30,9 @@
 #include "DataSource.h"
 #include "DataFormatter.h"
 #include "ContextDocumentsProxy.h"
+#include "ElementAttributesProxy.h"
+#include "EventParametersProxy.h"
+#include "SelectOptionsProxy.h"
 
 
 
@@ -62,6 +65,9 @@ LUATYPEDEFINE(ElementTabSet)
 LUATYPEDEFINE(DataSource)
 LUATYPEDEFINE(DataFormatter)
 LUATYPEDEFINE(ContextDocumentsProxy)
+LUATYPEDEFINE(ElementAttributesProxy)
+LUATYPEDEFINE(EventParametersProxy)
+LUATYPEDEFINE(SelectOptionsProxy)
 
 
 template class LuaType<Colourb>;
@@ -88,6 +94,9 @@ template class LuaType<ElementTabSet>;
 template class LuaType<DataSource>;
 template class LuaType<DataFormatter>;
 template class LuaType<ContextDocumentsProxy>;
+template class LuaType<ElementAttributesProxy>;
+template class LuaType<EventParametersProxy>;
+template class LuaType<SelectOptionsProxy>;
 
 
 //reference counted types
@@ -381,6 +390,24 @@ template<> void LuaType<ContextDocumentsProxy>::extra_init(lua_State* L, int met
     lua_setfield(L,metatable_index,"__index");
 }
 
+template<> void LuaType<ElementAttributesProxy>::extra_init(lua_State* L, int metatable_index)
+{
+    lua_pushcfunction(L,ElementAttributesProxy__index);
+    lua_setfield(L,metatable_index,"__index");
+}
+
+template<> void LuaType<EventParametersProxy>::extra_init(lua_State* L, int metatable_index)
+{
+    lua_pushcfunction(L,EventParametersProxy__index);
+    lua_setfield(L,metatable_index,"__index");
+}
+
+template<> void LuaType<SelectOptionsProxy>::extra_init(lua_State* L, int metatable_index)
+{
+    lua_pushcfunction(L,SelectOptionsProxy__index);
+    lua_setfield(L,metatable_index,"__index");
+}
+
 }
 }
 }

Source/Core/Lua/Utilities.cpp

@@ -0,0 +1,50 @@
+#include "precompiled.h"
+#include "Utilities.h"
+
+namespace Rocket {
+namespace Core {
+namespace Lua {
+
+void PushVariant(lua_State* L, Variant* var)
+{
+    if(var == NULL)
+    {
+        lua_pushnil(L);
+        return;
+    }
+    Variant::Type vartype = var->GetType();
+    switch(vartype)
+    {
+    case Variant::BYTE:
+    case Variant::CHAR:
+    case Variant::INT:
+        lua_pushinteger(L,var->Get<int>());
+        break;
+    case Variant::FLOAT:
+        lua_pushnumber(L,var->Get<float>());
+        break;
+    case Variant::COLOURB:
+        LuaType<Colourb>::push(L,new Colourb(var->Get<Colourb>()),true);
+        break;
+    case Variant::COLOURF:
+        LuaType<Colourf>::push(L,new Colourf(var->Get<Colourf>()),true);
+        break;
+    case Variant::STRING:
+        lua_pushstring(L,var->Get<String>().CString());
+        break;
+    case Variant::VECTOR2:
+        //according to Variant.inl, it is going to be a Vector2f
+        LuaType<Vector2f>::push(L,new Vector2f(var->Get<Vector2f>()),true);
+        break;
+    case Variant::VOIDPTR:
+        lua_pushlightuserdata(L,var->Get<void*>());
+        break;
+    default:
+        lua_pushnil(L);
+        break;
+    }
+}
+
+}
+}
+}

Source/Core/Lua/Utilities.h

@@ -0,0 +1,18 @@
+#pragma once
+/*
+    This file is for free-floating functions that are used across more than one file.
+*/
+#include <Rocket/Core/Lua/lua.hpp>
+#include <Rocket/Core/Lua/LuaType.h>
+#include <Rocket/Core/Variant.h>
+
+namespace Rocket {
+namespace Core {
+namespace Lua {
+
+//casts the variant to its specific type before pushing it to the stack
+void PushVariant(lua_State* L, Variant* var);
+
+}
+}
+}