Implemented Lua types: ElementDataGrid,ElementDataGridRow,ElementTabSet.

Registered all of the classes with the interpreter.

Added rocket.key_identifier table for Lua.

Build/RocketLua.vcproj

@@ -180,6 +180,30 @@
 		<Filter
 			Name="Controls"
 			>
+			<File
+				RelativePath="..\Source\Controls\Lua\ElementDataGrid.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\Source\Controls\Lua\ElementDataGrid.h"
+				>
+			</File>
+			<File
+				RelativePath="..\Source\Controls\Lua\ElementDataGridRow.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\Source\Controls\Lua\ElementDataGridRow.h"
+				>
+			</File>
+			<File
+				RelativePath="..\Source\Controls\Lua\ElementTabSet.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\Source\Controls\Lua\ElementTabSet.h"
+				>
+			</File>
 			<Filter
 				Name="Forms"
 				>

Source/Controls/Lua/ElementDataGrid.cpp

@@ -0,0 +1,87 @@
+#include "precompiled.h"
+#include "ElementDataGrid.h"
+#include <Rocket/Core/Element.h>
+#include <Rocket/Controls/ElementDataGridRow.h>
+
+using Rocket::Controls::ElementDataGridRow;
+namespace Rocket {
+namespace Core {
+namespace Lua {
+//this will be used to "inherit" from Element
+template<> void LuaType<ElementDataGrid>::extra_init(lua_State* L, int metatable_index)
+{
+    LuaType<Element>::extra_init(L,metatable_index);
+    LuaType<Element>::_regfunctions(L,metatable_index,metatable_index-1);
+}
+
+//methods
+int ElementDataGridAddColumn(lua_State* L, ElementDataGrid* obj)
+{
+    LUACHECKOBJ(obj);
+    const char* fields = luaL_checkstring(L,1);
+    const char* formatter = luaL_checkstring(L,2);
+    float width = (float)luaL_checknumber(L,3);
+    const char* rml = luaL_checkstring(L,4);
+
+    obj->AddColumn(fields,formatter,width,rml);
+    return 0;
+}
+
+int ElementDataGridSetDataSource(lua_State* L, ElementDataGrid* obj)
+{
+    LUACHECKOBJ(obj);
+    const char* source = luaL_checkstring(L,1);
+    
+    obj->SetDataSource(source);
+    return 0;
+}
+
+
+//getter
+int ElementDataGridGetAttrrows(lua_State* L)
+{
+    ElementDataGrid* obj = LuaType<ElementDataGrid>::check(L,1);
+    LUACHECKOBJ(obj);
+
+    lua_newtable(L);
+    int tbl = lua_gettop(L);
+    int numrows = obj->GetNumRows();
+    ElementDataGridRow* row;
+    for(int i = 0; i < numrows; i++)
+    {
+        row = obj->GetRow(i);
+        LuaType<ElementDataGridRow>::push(L,row,false);
+        lua_rawseti(L,tbl,i);
+    }
+    return 1;
+}
+
+
+
+RegType<ElementDataGrid> ElementDataGridMethods[] =
+{
+    LUAMETHOD(ElementDataGrid,AddColumn)
+    LUAMETHOD(ElementDataGrid,SetDataSource)
+    { NULL, NULL },
+};
+
+luaL_reg ElementDataGridGetters[] =
+{
+    LUAGETTER(ElementDataGrid,rows)
+    { NULL, NULL },
+};
+
+luaL_reg ElementDataGridSetters[] =
+{
+    { NULL, NULL },
+};
+
+
+template<> const char* GetTClassName<ElementDataGrid>() { return "ElementDataGrid"; }
+template<> RegType<ElementDataGrid>* GetMethodTable<ElementDataGrid>() { return ElementDataGridMethods; }
+template<> luaL_reg* GetAttrTable<ElementDataGrid>() { return ElementDataGridGetters; }
+template<> luaL_reg* SetAttrTable<ElementDataGrid>() { return ElementDataGridSetters; }
+
+}
+}
+}

Source/Controls/Lua/ElementDataGrid.h

@@ -0,0 +1,46 @@
+#pragma once
+/*
+    This defines the ElementDataGrid type in the Lua global namespace
+    
+    inherits from Element
+
+    //methods
+    noreturn ElementDataGrid:AddColumn(string fields, string formatter, float initial_width, string header_rml)
+    noreturn ElementDataGrid:SetDataSource(string data_source_name)
+
+    //getter
+    {}key=int,value=ElementDataGridRow ElementDataGrid.rows
+    --it returns a table, so you can acess it just like any other table. 
+*/
+
+#include <Rocket/Core/Lua/LuaType.h>
+#include <Rocket/Core/Lua/lua.hpp>
+#include <Rocket/Controls/ElementDataGrid.h>
+
+using Rocket::Controls::ElementDataGrid;
+namespace Rocket {
+namespace Core {
+namespace Lua {
+//this will be used to "inherit" from Element
+template<> void LuaType<ElementDataGrid>::extra_init(lua_State* L, int metatable_index);
+
+//methods
+int ElementDataGridAddColumn(lua_State* L, ElementDataGrid* obj);
+int ElementDataGridSetDataSource(lua_State* L, ElementDataGrid* obj);
+
+//getter
+int ElementDataGridGetAttrrows(lua_State* L);
+
+
+RegType<ElementDataGrid> ElementDataGridMethods[];
+luaL_reg ElementDataGridGetters[];
+luaL_reg ElementDataGridSetters[];
+
+template<> const char* GetTClassName<ElementDataGrid>();
+template<> RegType<ElementDataGrid>* GetMethodTable<ElementDataGrid>();
+template<> luaL_reg* GetAttrTable<ElementDataGrid>();
+template<> luaL_reg* SetAttrTable<ElementDataGrid>();
+
+}
+}
+}

Source/Controls/Lua/ElementDataGridRow.cpp

@@ -0,0 +1,101 @@
+#include "precompiled.h"
+#include "ElementDataGridRow.h"
+#include <Rocket/Controls/ElementDataGrid.h>
+
+using Rocket::Controls::ElementDataGrid;
+namespace Rocket {
+namespace Core {
+namespace Lua {
+//this will be used to "inherit" from Element
+template<> void LuaType<ElementDataGridRow>::extra_init(lua_State* L, int metatable_index)
+{
+    LuaType<Element>::extra_init(L,metatable_index);
+    LuaType<Element>::_regfunctions(L,metatable_index,metatable_index-1);
+}
+
+//getters
+int ElementDataGridRowGetAttrrow_expanded(lua_State* L)
+{
+    ElementDataGridRow* obj = LuaType<ElementDataGridRow>::check(L,1);
+    LUACHECKOBJ(obj);
+    lua_pushboolean(L,obj->IsRowExpanded());
+    return 1;
+}
+
+int ElementDataGridRowGetAttrparent_relative_index(lua_State* L)
+{
+    ElementDataGridRow* obj = LuaType<ElementDataGridRow>::check(L,1);
+    LUACHECKOBJ(obj);
+    lua_pushinteger(L,obj->GetParentRelativeIndex());
+    return 1;
+}
+
+int ElementDataGridRowGetAttrtable_relative_index(lua_State* L)
+{
+    ElementDataGridRow* obj = LuaType<ElementDataGridRow>::check(L,1);
+    LUACHECKOBJ(obj);
+    lua_pushinteger(L,obj->GetTableRelativeIndex());
+    return 1;
+}
+
+int ElementDataGridRowGetAttrparent_row(lua_State* L)
+{
+    ElementDataGridRow* obj = LuaType<ElementDataGridRow>::check(L,1);
+    LUACHECKOBJ(obj);
+    LuaType<ElementDataGridRow>::push(L,obj->GetParentRow(),false);
+    return 1;
+}
+
+int ElementDataGridRowGetAttrparent_grid(lua_State* L)
+{
+    ElementDataGridRow* obj = LuaType<ElementDataGridRow>::check(L,1);
+    LUACHECKOBJ(obj);
+    LuaType<ElementDataGrid>::push(L,obj->GetParentGrid(),false);
+    return 1;
+}
+
+
+//setter
+int ElementDataGridRowSetAttrrow_expanded(lua_State* L)
+{
+    ElementDataGridRow* obj = LuaType<ElementDataGridRow>::check(L,1);
+    LUACHECKOBJ(obj);
+    bool expanded = CHECK_BOOL(L,2);
+    if(expanded)
+        obj->ExpandRow();
+    else
+        obj->CollapseRow();
+    return 0;
+}
+
+
+
+RegType<ElementDataGridRow> ElementDataGridRowMethods[] =
+{
+    { NULL, NULL },
+};
+
+luaL_reg ElementDataGridRowGetters[] =
+{
+    LUAGETTER(ElementDataGridRow,row_expanded)
+    LUAGETTER(ElementDataGridRow,parent_relative_index)
+    LUAGETTER(ElementDataGridRow,table_relative_index)
+    LUAGETTER(ElementDataGridRow,parent_row)
+    LUAGETTER(ElementDataGridRow,parent_grid)
+    { NULL, NULL },
+};
+
+luaL_reg ElementDataGridRowSetters[] =
+{
+    LUASETTER(ElementDataGridRow,row_expanded)
+    { NULL, NULL },
+};
+
+template<> const char* GetTClassName<ElementDataGridRow>() { return "ElementDataGridRow"; }
+template<> RegType<ElementDataGridRow>* GetMethodTable<ElementDataGridRow>() { return ElementDataGridRowMethods; }
+template<> luaL_reg* GetAttrTable<ElementDataGridRow>() { return ElementDataGridRowGetters; }
+template<> luaL_reg* SetAttrTable<ElementDataGridRow>() { return ElementDataGridRowSetters; }
+
+}
+}
+}

Source/Controls/Lua/ElementDataGridRow.h

@@ -0,0 +1,53 @@
+#pragma once
+/*
+    This defines the ElementDataGridRow type in the Lua global namespace
+
+    inherits from Element
+
+    no methods
+
+    //getters
+    bool ElementDataGridRow.row_expanded
+    int ElementDataGridRow.parent_relative_index
+    int ElementDataGridRow.table_relative_index
+    ElementDataGridRow ElementDataGridRow.parent_row
+    ElementDataGrid ElementDataGridRow.parent_grid
+
+    //setter
+    ElementDataGridRow.row_expanded = bool
+*/
+
+#include <Rocket/Core/Lua/LuaType.h>
+#include <Rocket/Core/Lua/lua.hpp>
+#include <Rocket/Controls/ElementDataGridRow.h>
+
+using Rocket::Controls::ElementDataGridRow;
+namespace Rocket {
+namespace Core {
+namespace Lua {
+//this will be used to "inherit" from Element
+template<> void LuaType<ElementDataGridRow>::extra_init(lua_State* L, int metatable_index);
+
+//getters
+int ElementDataGridRowGetAttrrow_expanded(lua_State* L);
+int ElementDataGridRowGetAttrparent_relative_index(lua_State* L);
+int ElementDataGridRowGetAttrtable_relative_index(lua_State* L);
+int ElementDataGridRowGetAttrparent_row(lua_State* L);
+int ElementDataGridRowGetAttrparent_grid(lua_State* L);
+
+//setter
+int ElementDataGridRowSetAttrrow_expanded(lua_State* L);
+
+
+RegType<ElementDataGridRow> ElementDataGridRowMethods[];
+luaL_reg ElementDataGridRowGetters[];
+luaL_reg ElementDataGridRowSetters[];
+
+template<> const char* GetTClassName<ElementDataGridRow>();
+template<> RegType<ElementDataGridRow>* GetMethodTable<ElementDataGridRow>();
+template<> luaL_reg* GetAttrTable<ElementDataGridRow>();
+template<> luaL_reg* SetAttrTable<ElementDataGridRow>();
+
+}
+}
+}

Source/Controls/Lua/ElementForm.h

@@ -11,12 +11,6 @@
 #include <Rocket/Core/Lua/LuaType.h>
 #include <Rocket/Core/Lua/lua.hpp>
 #include <Rocket/Controls/ElementForm.h>
-/*
-    This defines the ElementForm type in the Lua global namespace
-
-    It has one method
-    noreturn ElementForm:Submit(string name,string value)
-*/
 
 using Rocket::Controls::ElementForm;
 namespace Rocket {

Source/Controls/Lua/ElementTabSet.cpp

@@ -0,0 +1,96 @@
+#include "precompiled.h"
+#include "ElementTabSet.h"
+#include <Rocket/Core/Element.h>
+
+
+namespace Rocket {
+namespace Core {
+namespace Lua {
+//this will be used to "inherit" from Element
+template<> void LuaType<ElementTabSet>::extra_init(lua_State* L, int metatable_index)
+{
+    LuaType<Element>::extra_init(L,metatable_index);
+    LuaType<Element>::_regfunctions(L,metatable_index,metatable_index-1);
+}
+
+//methods
+int ElementTabSetSetPanel(lua_State* L, ElementTabSet* obj)
+{
+    LUACHECKOBJ(obj);
+    int index = luaL_checkint(L,1);
+    const char* rml = luaL_checkstring(L,2);
+
+    obj->SetPanel(index,rml);
+    return 0;
+}
+
+int ElementTabSetSetTab(lua_State* L, ElementTabSet* obj)
+{
+    LUACHECKOBJ(obj);
+    int index = luaL_checkint(L,1);
+    const char* rml = luaL_checkstring(L,2);
+
+    obj->SetTab(index,rml);
+    return 0;
+}
+
+
+//getters
+int ElementTabSetGetAttractive_tab(lua_State* L)
+{
+    ElementTabSet* obj = LuaType<ElementTabSet>::check(L,1);
+    LUACHECKOBJ(obj);
+    int tab = obj->GetActiveTab();
+    lua_pushinteger(L,tab);
+    return 1;
+}
+
+int ElementTabSetGetAttrnum_tabs(lua_State* L)
+{
+    ElementTabSet* obj = LuaType<ElementTabSet>::check(L,1);
+    LUACHECKOBJ(obj);
+    int num = obj->GetNumTabs();
+    lua_pushinteger(L,num);
+    return 1;
+}
+
+
+//setter
+int ElementTabSetSetAttractive_tab(lua_State* L)
+{
+    ElementTabSet* obj = LuaType<ElementTabSet>::check(L,1);
+    LUACHECKOBJ(obj);
+    int tab = luaL_checkint(L,2);
+    obj->SetActiveTab(tab);
+    return 0;
+}
+
+
+RegType<ElementTabSet> ElementTabSetMethods[] =
+{
+    LUAMETHOD(ElementTabSet,SetPanel)
+    LUAMETHOD(ElementTabSet,SetTab)
+    { NULL, NULL },
+};
+
+luaL_reg ElementTabSetGetters[] =
+{
+    LUAGETTER(ElementTabSet,active_tab)
+    LUAGETTER(ElementTabSet,num_tabs)
+    { NULL, NULL },
+};
+
+luaL_reg ElementTabSetSetters[] =
+{
+    LUASETTER(ElementTabSet,active_tab)
+    { NULL, NULL },
+};
+
+template<> const char* GetTClassName<ElementTabSet>() { return "ElementTabSet"; }
+template<> RegType<ElementTabSet>* GetMethodTable<ElementTabSet>() { return ElementTabSetMethods; }
+template<> luaL_reg* GetAttrTable<ElementTabSet>() { return ElementTabSetGetters; }
+template<> luaL_reg* SetAttrTable<ElementTabSet>() { return ElementTabSetSetters; }
+
+}
+}
+}

Source/Controls/Lua/ElementTabSet.h

@@ -0,0 +1,52 @@
+#pragma once
+/*
+    This defines the ElementTabSet type in the Lua global namespace
+
+    It inherits from Element
+
+    //methods:
+    noreturn ElementTabSet:SetPanel(int index, string rml)
+    noreturn ElementTabSet:SetTab(int index, string rml)
+
+    //getters
+    int ElementTabSet.active_tab
+    int ElementTabSet.num_tabs
+
+    //setter
+    ElementTabSet.active_tab = int
+*/
+
+#include <Rocket/Core/Lua/LuaType.h>
+#include <Rocket/Core/Lua/lua.hpp>
+#include <Rocket/Controls/ElementTabSet.h>
+
+using Rocket::Controls::ElementTabSet;
+namespace Rocket {
+namespace Core {
+namespace Lua {
+//this will be used to "inherit" from Element
+template<> void LuaType<ElementTabSet>::extra_init(lua_State* L, int metatable_index);
+
+//methods
+int ElementTabSetSetPanel(lua_State* L, ElementTabSet* obj);
+int ElementTabSetSetTab(lua_State* L, ElementTabSet* obj);
+
+//getters
+int ElementTabSetGetAttractive_tab(lua_State* L);
+int ElementTabSetGetAttrnum_tabs(lua_State* L);
+
+//setter
+int ElementTabSetSetAttractive_tab(lua_State* L);
+
+RegType<ElementTabSet> ElementTabSetMethods[];
+luaL_reg ElementTabSetGetters[];
+luaL_reg ElementTabSetSetters[];
+
+template<> const char* GetTClassName<ElementTabSet>();
+template<> RegType<ElementTabSet>* GetMethodTable<ElementTabSet>();
+template<> luaL_reg* GetAttrTable<ElementTabSet>();
+template<> luaL_reg* SetAttrTable<ElementTabSet>();
+
+}
+}
+}

Source/Core/Lua/Interpreter.cpp

@@ -6,6 +6,7 @@
 #include "LuaDocumentElementInstancer.h"
 #include <Rocket/Core/Factory.h>
 #include "LuaEventListenerInstancer.h"
+#include "Rocket.h"
 
 namespace Rocket {
 namespace Core {
@@ -34,8 +35,16 @@ void Interpreter::RegisterEverything(lua_State* L)
         LuaType<Document>::Register(L);
         LuaType<ElementStyle>::Register(L);
         //controls that inherit from Element
+        LuaType<Rocket::Controls::ElementTabSet>::Register(L);
+        LuaType<Rocket::Controls::ElementDataGrid>::Register(L);
+        LuaType<Rocket::Controls::ElementDataGridRow>::Register(L);
         LuaType<Rocket::Controls::ElementForm>::Register(L);
         LuaType<Rocket::Controls::ElementFormControl>::Register(L);
+            //inherits from ElementFormControl
+            LuaType<Rocket::Controls::ElementFormControlSelect>::Register(L);
+            LuaType<Rocket::Controls::ElementFormControlDataSelect>::Register(L);
+            LuaType<Rocket::Controls::ElementFormControlInput>::Register(L);
+            LuaType<Rocket::Controls::ElementFormControlTextArea>::Register(L);
     LuaType<Event>::Register(L);
     LuaType<Context>::Register(L);
     LuaType<rocket>::Register(L);
@@ -154,4 +163,4 @@ void Interpreter::OnShutdown()
 
 }
 }
-}
+}

Source/Core/Lua/Rocket.cpp

@@ -1,6 +1,7 @@
 #include "precompiled.h"
 #include "Rocket.h"
 #include <Rocket/Core/Core.h>
+#include <Rocket/Core/Input.h>
 
 namespace Rocket {
 namespace Core {
@@ -21,6 +22,8 @@ template<> void LuaType<rocket>::extra_init(lua_State* L, int metatable_index)
     lua_pushcfunction(L,rocketRegisterTag);
     lua_setfield(L,method_index,"RegisterTag");
 
+    rocketEnumkey_identifier(L);
+
     return;
 }
 
@@ -50,12 +53,209 @@ int rocketLoadFontFace(lua_State* L)
 
 int rocketRegisterTag(lua_State* L)
 {
+    //this may take some thought
     return 0;
 }
 
 int rocketGetAttrcontexts(lua_State* L)
 {
-    return 0;
+    lua_newtable(L);
+    int tbl = lua_gettop(L);
+    int numcontexts = GetNumContexts();
+    Context* cont;
+    for(int i = 0; i < numcontexts; i++)
+    {
+        cont = GetContext(i);
+        if(cont != NULL)
+        {
+            LuaType<Context>::push(L,cont,false);
+            lua_pushvalue(L,-1); //duplicate the top of the stack, because we are indexing by string and integral key so we need two
+            lua_rawseti(L,tbl,i);
+            lua_setfield(L,tbl,cont->GetName().CString());
+        }
+    }
+    return 1;
+}
+
+void rocketEnumkey_identifier(lua_State* L)
+{
+    lua_newtable(L);
+    int tbl = lua_gettop(L);
+	ROCKETLUA_INPUTENUM(UNKNOWN,tbl)
+	ROCKETLUA_INPUTENUM(SPACE,tbl)
+	ROCKETLUA_INPUTENUM(0,tbl)
+	ROCKETLUA_INPUTENUM(1,tbl)
+	ROCKETLUA_INPUTENUM(2,tbl)
+	ROCKETLUA_INPUTENUM(3,tbl)
+	ROCKETLUA_INPUTENUM(4,tbl)
+	ROCKETLUA_INPUTENUM(5,tbl)
+	ROCKETLUA_INPUTENUM(6,tbl)
+	ROCKETLUA_INPUTENUM(7,tbl)
+	ROCKETLUA_INPUTENUM(8,tbl)
+	ROCKETLUA_INPUTENUM(9,tbl)
+	ROCKETLUA_INPUTENUM(A,tbl)
+	ROCKETLUA_INPUTENUM(B,tbl)
+	ROCKETLUA_INPUTENUM(C,tbl)
+	ROCKETLUA_INPUTENUM(D,tbl)
+	ROCKETLUA_INPUTENUM(E,tbl)
+	ROCKETLUA_INPUTENUM(F,tbl)
+	ROCKETLUA_INPUTENUM(G,tbl)
+	ROCKETLUA_INPUTENUM(H,tbl)
+	ROCKETLUA_INPUTENUM(I,tbl)
+	ROCKETLUA_INPUTENUM(J,tbl)
+	ROCKETLUA_INPUTENUM(K,tbl)
+	ROCKETLUA_INPUTENUM(L,tbl)
+	ROCKETLUA_INPUTENUM(M,tbl)
+	ROCKETLUA_INPUTENUM(N,tbl)
+	ROCKETLUA_INPUTENUM(O,tbl)
+	ROCKETLUA_INPUTENUM(P,tbl)
+	ROCKETLUA_INPUTENUM(Q,tbl)
+	ROCKETLUA_INPUTENUM(R,tbl)
+	ROCKETLUA_INPUTENUM(S,tbl)
+	ROCKETLUA_INPUTENUM(T,tbl)
+	ROCKETLUA_INPUTENUM(U,tbl)
+	ROCKETLUA_INPUTENUM(V,tbl)
+	ROCKETLUA_INPUTENUM(W,tbl)
+	ROCKETLUA_INPUTENUM(X,tbl)
+	ROCKETLUA_INPUTENUM(Y,tbl)
+	ROCKETLUA_INPUTENUM(Z,tbl)
+	ROCKETLUA_INPUTENUM(OEM_1,tbl)
+	ROCKETLUA_INPUTENUM(OEM_PLUS,tbl)
+	ROCKETLUA_INPUTENUM(OEM_COMMA,tbl)
+	ROCKETLUA_INPUTENUM(OEM_MINUS,tbl)
+	ROCKETLUA_INPUTENUM(OEM_PERIOD,tbl)
+	ROCKETLUA_INPUTENUM(OEM_2,tbl)
+	ROCKETLUA_INPUTENUM(OEM_3,tbl)
+	ROCKETLUA_INPUTENUM(OEM_4,tbl)
+	ROCKETLUA_INPUTENUM(OEM_5,tbl)
+	ROCKETLUA_INPUTENUM(OEM_6,tbl)
+	ROCKETLUA_INPUTENUM(OEM_7,tbl)
+	ROCKETLUA_INPUTENUM(OEM_8,tbl)
+	ROCKETLUA_INPUTENUM(OEM_102,tbl)
+	ROCKETLUA_INPUTENUM(NUMPAD0,tbl)
+	ROCKETLUA_INPUTENUM(NUMPAD1,tbl)
+	ROCKETLUA_INPUTENUM(NUMPAD2,tbl)
+	ROCKETLUA_INPUTENUM(NUMPAD3,tbl)
+	ROCKETLUA_INPUTENUM(NUMPAD4,tbl)
+	ROCKETLUA_INPUTENUM(NUMPAD5,tbl)
+	ROCKETLUA_INPUTENUM(NUMPAD6,tbl)
+	ROCKETLUA_INPUTENUM(NUMPAD7,tbl)
+	ROCKETLUA_INPUTENUM(NUMPAD8,tbl)
+	ROCKETLUA_INPUTENUM(NUMPAD9,tbl)
+	ROCKETLUA_INPUTENUM(NUMPADENTER,tbl)
+	ROCKETLUA_INPUTENUM(MULTIPLY,tbl)
+	ROCKETLUA_INPUTENUM(ADD,tbl)
+	ROCKETLUA_INPUTENUM(SEPARATOR,tbl)
+	ROCKETLUA_INPUTENUM(SUBTRACT,tbl)
+	ROCKETLUA_INPUTENUM(DECIMAL,tbl)
+	ROCKETLUA_INPUTENUM(DIVIDE,tbl)
+	ROCKETLUA_INPUTENUM(OEM_NEC_EQUAL,tbl)
+	ROCKETLUA_INPUTENUM(BACK,tbl)
+	ROCKETLUA_INPUTENUM(TAB,tbl)
+	ROCKETLUA_INPUTENUM(CLEAR,tbl)
+	ROCKETLUA_INPUTENUM(RETURN,tbl)
+	ROCKETLUA_INPUTENUM(PAUSE,tbl)
+	ROCKETLUA_INPUTENUM(CAPITAL,tbl)
+	ROCKETLUA_INPUTENUM(KANA,tbl)
+	ROCKETLUA_INPUTENUM(HANGUL,tbl)
+	ROCKETLUA_INPUTENUM(JUNJA,tbl)
+	ROCKETLUA_INPUTENUM(FINAL,tbl)
+	ROCKETLUA_INPUTENUM(HANJA,tbl)
+	ROCKETLUA_INPUTENUM(KANJI,tbl)
+	ROCKETLUA_INPUTENUM(ESCAPE,tbl)
+	ROCKETLUA_INPUTENUM(CONVERT,tbl)
+	ROCKETLUA_INPUTENUM(NONCONVERT,tbl)
+	ROCKETLUA_INPUTENUM(ACCEPT,tbl)
+	ROCKETLUA_INPUTENUM(MODECHANGE,tbl)
+	ROCKETLUA_INPUTENUM(PRIOR,tbl)
+	ROCKETLUA_INPUTENUM(NEXT,tbl)
+	ROCKETLUA_INPUTENUM(END,tbl)
+	ROCKETLUA_INPUTENUM(HOME,tbl)
+	ROCKETLUA_INPUTENUM(LEFT,tbl)
+	ROCKETLUA_INPUTENUM(UP,tbl)
+	ROCKETLUA_INPUTENUM(RIGHT,tbl)
+	ROCKETLUA_INPUTENUM(DOWN,tbl)
+	ROCKETLUA_INPUTENUM(SELECT,tbl)
+	ROCKETLUA_INPUTENUM(PRINT,tbl)
+	ROCKETLUA_INPUTENUM(EXECUTE,tbl)
+	ROCKETLUA_INPUTENUM(SNAPSHOT,tbl)
+	ROCKETLUA_INPUTENUM(INSERT,tbl)
+	ROCKETLUA_INPUTENUM(DELETE,tbl)
+	ROCKETLUA_INPUTENUM(HELP,tbl)
+	ROCKETLUA_INPUTENUM(LWIN,tbl)
+	ROCKETLUA_INPUTENUM(RWIN,tbl)
+	ROCKETLUA_INPUTENUM(APPS,tbl)
+	ROCKETLUA_INPUTENUM(POWER,tbl)
+	ROCKETLUA_INPUTENUM(SLEEP,tbl)
+	ROCKETLUA_INPUTENUM(WAKE,tbl)
+	ROCKETLUA_INPUTENUM(F1,tbl)
+	ROCKETLUA_INPUTENUM(F2,tbl)
+	ROCKETLUA_INPUTENUM(F3,tbl)
+	ROCKETLUA_INPUTENUM(F4,tbl)
+	ROCKETLUA_INPUTENUM(F5,tbl)
+	ROCKETLUA_INPUTENUM(F6,tbl)
+	ROCKETLUA_INPUTENUM(F7,tbl)
+	ROCKETLUA_INPUTENUM(F8,tbl)
+	ROCKETLUA_INPUTENUM(F9,tbl)
+	ROCKETLUA_INPUTENUM(F10,tbl)
+	ROCKETLUA_INPUTENUM(F11,tbl)
+	ROCKETLUA_INPUTENUM(F12,tbl)
+	ROCKETLUA_INPUTENUM(F13,tbl)
+	ROCKETLUA_INPUTENUM(F14,tbl)
+	ROCKETLUA_INPUTENUM(F15,tbl)
+	ROCKETLUA_INPUTENUM(F16,tbl)
+	ROCKETLUA_INPUTENUM(F17,tbl)
+	ROCKETLUA_INPUTENUM(F18,tbl)
+	ROCKETLUA_INPUTENUM(F19,tbl)
+	ROCKETLUA_INPUTENUM(F20,tbl)
+	ROCKETLUA_INPUTENUM(F21,tbl)
+	ROCKETLUA_INPUTENUM(F22,tbl)
+	ROCKETLUA_INPUTENUM(F23,tbl)
+	ROCKETLUA_INPUTENUM(F24,tbl)
+	ROCKETLUA_INPUTENUM(NUMLOCK,tbl)
+	ROCKETLUA_INPUTENUM(SCROLL,tbl)
+	ROCKETLUA_INPUTENUM(OEM_FJ_JISHO,tbl)
+	ROCKETLUA_INPUTENUM(OEM_FJ_MASSHOU,tbl)
+	ROCKETLUA_INPUTENUM(OEM_FJ_TOUROKU,tbl)
+	ROCKETLUA_INPUTENUM(OEM_FJ_LOYA,tbl)
+	ROCKETLUA_INPUTENUM(OEM_FJ_ROYA,tbl)
+	ROCKETLUA_INPUTENUM(LSHIFT,tbl)
+	ROCKETLUA_INPUTENUM(RSHIFT,tbl)
+	ROCKETLUA_INPUTENUM(LCONTROL,tbl)
+	ROCKETLUA_INPUTENUM(RCONTROL,tbl)
+	ROCKETLUA_INPUTENUM(LMENU,tbl)
+	ROCKETLUA_INPUTENUM(RMENU,tbl)
+	ROCKETLUA_INPUTENUM(BROWSER_BACK,tbl)
+	ROCKETLUA_INPUTENUM(BROWSER_FORWARD,tbl)
+	ROCKETLUA_INPUTENUM(BROWSER_REFRESH,tbl)
+	ROCKETLUA_INPUTENUM(BROWSER_STOP,tbl)
+	ROCKETLUA_INPUTENUM(BROWSER_SEARCH,tbl)
+	ROCKETLUA_INPUTENUM(BROWSER_FAVORITES,tbl)
+	ROCKETLUA_INPUTENUM(BROWSER_HOME,tbl)
+	ROCKETLUA_INPUTENUM(VOLUME_MUTE,tbl)
+	ROCKETLUA_INPUTENUM(VOLUME_DOWN,tbl)
+	ROCKETLUA_INPUTENUM(VOLUME_UP,tbl)
+	ROCKETLUA_INPUTENUM(MEDIA_NEXT_TRACK,tbl)
+	ROCKETLUA_INPUTENUM(MEDIA_PREV_TRACK,tbl)
+	ROCKETLUA_INPUTENUM(MEDIA_STOP,tbl)
+	ROCKETLUA_INPUTENUM(MEDIA_PLAY_PAUSE,tbl)
+	ROCKETLUA_INPUTENUM(LAUNCH_MAIL,tbl)
+	ROCKETLUA_INPUTENUM(LAUNCH_MEDIA_SELECT,tbl)
+	ROCKETLUA_INPUTENUM(LAUNCH_APP1,tbl)
+	ROCKETLUA_INPUTENUM(LAUNCH_APP2,tbl)
+	ROCKETLUA_INPUTENUM(OEM_AX,tbl)
+	ROCKETLUA_INPUTENUM(ICO_HELP,tbl)
+	ROCKETLUA_INPUTENUM(ICO_00,tbl)
+	ROCKETLUA_INPUTENUM(PROCESSKEY,tbl)
+	ROCKETLUA_INPUTENUM(ICO_CLEAR,tbl)
+	ROCKETLUA_INPUTENUM(ATTN,tbl)
+	ROCKETLUA_INPUTENUM(CRSEL,tbl)
+	ROCKETLUA_INPUTENUM(EXSEL,tbl)
+	ROCKETLUA_INPUTENUM(EREOF,tbl)
+	ROCKETLUA_INPUTENUM(PLAY,tbl)
+	ROCKETLUA_INPUTENUM(ZOOM,tbl)
+	ROCKETLUA_INPUTENUM(PA1,tbl)
+	ROCKETLUA_INPUTENUM(OEM_CLEAR,tbl)
 }
 
 

Source/Core/Lua/Rocket.h

@@ -10,7 +10,7 @@
     rocket.LoadFontFace(string font_path)
     
     getters:
-    rocket.contexts  returns a table of contexts, which are indexed by number or string
+    rocket.contexts  returns a table of contexts, which are indexed by number AND string, so there are two copies of each context in the table
 
 */
 
@@ -20,6 +20,7 @@
 namespace Rocket {
 namespace Core {
 namespace Lua {
+#define ROCKETLUA_INPUTENUM(keyident,tbl) lua_pushinteger(L,Input::KI_##keyident); lua_setfield(L,(tbl),#keyident);
 
 //just need a class to take up a type name
 class rocket { int to_remove_warning; };
@@ -30,6 +31,8 @@ int rocketLoadFontFace(lua_State* L);
 int rocketRegisterTag(lua_State* L);
 int rocketGetAttrcontexts(lua_State* L);
 
+void rocketEnumkey_identifier(lua_State* L);
+
 RegType<rocket> rocketMethods[];
 luaL_reg rocketGetters[];
 luaL_reg rocketSetters[];