namespace Lua {
//inherits from ElementFormControl which inherits from Element
//method
int ElementFormControlDataSelectSetDataSource(lua_State* L, ElementFormControlDataSelect* obj)
{
const char* source = luaL_checkstring(L,1);
obj->SetDataSource(source);
return 0;
}
RegType<ElementFormControlDataSelect> ElementFormControlDataSelectMethods[] =
{
LUAMETHOD(ElementFormControlDataSelect,SetDataSource)
{ NULL, NULL },
};
luaL_reg ElementFormControlDataSelectGetters[] =
{
{ NULL, NULL },
};
luaL_reg ElementFormControlDataSelectSetters[] =
{
{ NULL, NULL },
};
/*
template<> const char* GetTClassName<ElementFormControlDataSelect>() { return "ElementFormControlDataSelect"; }
template<> RegType<ElementFormControlDataSelect>* GetMethodTable<ElementFormControlDataSelect>() { return ElementFormControlDataSelectMethods; }
template<> luaL_reg* GetAttrTable<ElementFormControlDataSelect>() { return ElementFormControlDataSelectGetters; }
template<> luaL_reg* SetAttrTable<ElementFormControlDataSelect>() { return ElementFormControlDataSelectSetters; }
*/
}
namespace Lua {
//method
int EventStopPropagation(lua_State* L, Event* obj)
{
obj->StopPropagation();
return 0;
}
//getters
int EventGetAttrcurrent_element(lua_State* L)
{
Event* evt = LuaType<Event>::check(L,1);
LUACHECKOBJ(evt);
Element* ele = evt->GetCurrentElement();
LuaType<Element>::push(L,ele,false);
return 1;
}
int EventGetAttrtype(lua_State* L)
{
Event* evt = LuaType<Event>::check(L,1);
LUACHECKOBJ(evt);
String type = evt->GetType();
lua_pushstring(L,type.CString());
return 1;
}
int EventGetAttrtarget_element(lua_State* L)
{
Event* evt = LuaType<Event>::check(L,1);
LUACHECKOBJ(evt);
Element* target = evt->GetTargetElement();
LuaType<Element>::push(L,target,false);
return 1;
}
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);
}
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)
{ NULL, NULL },
};
luaL_reg EventGetters[] =
{
LUAGETTER(Event,current_element)
LUAGETTER(Event,type)
LUAGETTER(Event,target_element)
LUAGETTER(Event,parameters)
{ NULL, NULL },
};
luaL_reg EventSetters[] =
{
//LUASETTER(Event,parameters)
{ NULL, NULL },
};
/*
template<> const char* GetTClassName<Event>() { return "Event"; }
template<> RegType<Event>* GetMethodTable<Event>() { return EventMethods; }
template<> luaL_reg* GetAttrTable<Event>() { return EventGetters; }
template<> luaL_reg* SetAttrTable<Event>() { return EventSetters; }
*/
}
namespace Lua {
//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;
}
Rocket::Core::Lua::RegType<ElementDataGrid> ElementDataGridMethods[] =
{
LUAMETHOD(ElementDataGrid,AddColumn)
LUAMETHOD(ElementDataGrid,SetDataSource)
{ NULL, NULL },
};
luaL_Reg ElementDataGridGetters[] =
{
LUAGETTER(ElementDataGrid,rows)
{ NULL, NULL },
};
luaL_Reg ElementDataGridSetters[] =
{
{ NULL, NULL },
};
}
namespace Lua {
//methods
int ElementFormControlSelectAdd(lua_State* L, ElementFormControlSelect* obj)
{
const char* rml = luaL_checkstring(L,1);
const char* value = luaL_checkstring(L,2);
int before = -1; //default
if(lua_gettop(L) >= 3)
before = luaL_checkinteger(L,3);
int index = obj->Add(rml,value,before);
lua_pushinteger(L,index);
return 1;
}
int ElementFormControlSelectRemove(lua_State* L, ElementFormControlSelect* obj)
{
int index = luaL_checkinteger(L,1);
obj->Remove(index);
return 0;
}
//getters
int ElementFormControlSelectGetAttroptions(lua_State* L)
{
ElementFormControlSelect* obj = LuaType<ElementFormControlSelect>::check(L,1);
LUACHECKOBJ(obj);
SelectOptionsProxy* proxy = new SelectOptionsProxy();
proxy->owner = obj;
LuaType<SelectOptionsProxy>::push(L,proxy,true);
return 1;
}
int ElementFormControlSelectGetAttrselection(lua_State* L)
{
ElementFormControlSelect* obj = LuaType<ElementFormControlSelect>::check(L,1);
LUACHECKOBJ(obj);
int selection = obj->GetSelection();
lua_pushinteger(L,selection);
return 1;
}
//setter
int ElementFormControlSelectSetAttrselection(lua_State* L)
{
ElementFormControlSelect* obj = LuaType<ElementFormControlSelect>::check(L,1);
LUACHECKOBJ(obj);
int selection = luaL_checkinteger(L,2);
obj->SetSelection(selection);
return 0;
}
Rocket::Core::Lua::RegType<ElementFormControlSelect> ElementFormControlSelectMethods[] =
{
LUAMETHOD(ElementFormControlSelect,Add)
LUAMETHOD(ElementFormControlSelect,Remove)
{ NULL, NULL },
};
luaL_Reg ElementFormControlSelectGetters[] =
{
LUAGETTER(ElementFormControlSelect,options)
LUAGETTER(ElementFormControlSelect,selection)
{ NULL, NULL },
};
luaL_Reg ElementFormControlSelectSetters[] =
{
LUASETTER(ElementFormControlSelect,selection)
{ NULL, NULL },
};
}
namespace Lua {
typedef LuaDataSource DataSource;
int DataSourceNotifyRowAdd(lua_State* L, DataSource* obj)
{
LUACHECKOBJ(obj);
const char* table_name = luaL_checkstring(L,1);
int first_row_added = luaL_checkint(L,2);
int num_rows_added = luaL_checkint(L,3);
obj->NotifyRowAdd(table_name,first_row_added,num_rows_added);
return 0;
}
int DataSourceNotifyRowRemove(lua_State* L, DataSource* obj)
{
LUACHECKOBJ(obj);
const char* table_name = luaL_checkstring(L,1);
int first_row_removed = luaL_checkint(L,2);
int num_rows_removed = luaL_checkint(L,3);
obj->NotifyRowRemove(table_name,first_row_removed,num_rows_removed);
return 0;
}
int DataSourceNotifyRowChange(lua_State* L, DataSource* obj)
{
LUACHECKOBJ(obj);
const char* table_name = luaL_checkstring(L,1);
if(lua_gettop(L) < 2)
{
obj->NotifyRowChange(table_name);
}
else
{
int first_row_changed = luaL_checkint(L,2);
int num_rows_changed = luaL_checkint(L,3);
obj->NotifyRowChange(table_name,first_row_changed,num_rows_changed);
}
return 0;
}
int DataSourceSetAttrGetNumRows(lua_State* L)
{
DataSource* obj = LuaType<DataSource>::check(L,1);
LUACHECKOBJ(obj);
if(lua_type(L,2) == LUA_TFUNCTION)
{
lua_pushvalue(L,2); //copy of the function, so it is for sure at the top of the stack
obj->getNumRowsRef = lua_ref(L,true);
}
else
Log::Message(Log::LT_WARNING, "Lua: Must assign DataSource.GetNumRows as a function, value received was of %s type", lua_typename(L,2));
return 0;
}
int DataSourceSetAttrGetRow(lua_State* L)
{
DataSource* obj = LuaType<DataSource>::check(L,1);
LUACHECKOBJ(obj);
if(lua_type(L,2) == LUA_TFUNCTION)
{
lua_pushvalue(L,2); //copy of the functions, so it is for sure at the top of the stack
obj->getRowRef = lua_ref(L,true);
}
else
Log::Message(Log::LT_WARNING, "Lua: Must assign DataSource.GetRow as a function, value received was of %s type", lua_typename(L,2));
return 0;
}
RegType<DataSource> DataSourceMethods[] =
{
LUAMETHOD(DataSource,NotifyRowAdd)
LUAMETHOD(DataSource,NotifyRowRemove)
LUAMETHOD(DataSource,NotifyRowChange)
{ NULL, NULL },
};
luaL_reg DataSourceGetters[] =
{
{ NULL, NULL },
};
luaL_reg DataSourceSetters[] =
{
LUASETTER(DataSource,GetNumRows)
LUASETTER(DataSource,GetRow)
{ NULL, NULL },
};
}
namespace Lua {
//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;
}
Rocket::Core::Lua::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 },
};
}
namespace Lua {
int Vector2fnew(lua_State* L)
{
float x = (float)luaL_checknumber(L,1);
float y = (float)luaL_checknumber(L,2);
Vector2f* vect = new Vector2f(x,y);
LuaType<Vector2f>::push(L,vect,true); //true means it will be deleted when it is garbage collected
return 1;
}
int Vector2f__mul(lua_State* L)
{
Vector2f* lhs = LuaType<Vector2f>::check(L,1);
LUACHECKOBJ(lhs);
float rhs = (float)luaL_checknumber(L,2);
Vector2f* res = new Vector2f(*lhs);
(*res) *= rhs;
LuaType<Vector2f>::push(L,res,true);
return 1;
}
int Vector2f__div(lua_State* L)
{
Vector2f* lhs = LuaType<Vector2f>::check(L,1);
LUACHECKOBJ(lhs);
float rhs = (float)luaL_checknumber(L,2);
Vector2f* res = new Vector2f(*lhs);
(*res) /= rhs;
LuaType<Vector2f>::push(L,res,true);
return 1;
}
int Vector2f__add(lua_State* L)
{
Vector2f* lhs = LuaType<Vector2f>::check(L,1);
LUACHECKOBJ(lhs);
Vector2f* rhs = LuaType<Vector2f>::check(L,2);
LUACHECKOBJ(rhs);
Vector2f* res = new Vector2f(*lhs);
(*res) += (*rhs);
LuaType<Vector2f>::push(L,res,true);
return 1;
}
int Vector2f__sub(lua_State* L)
{
Vector2f* lhs = LuaType<Vector2f>::check(L,1);
LUACHECKOBJ(lhs);
Vector2f* rhs = LuaType<Vector2f>::check(L,2);
LUACHECKOBJ(rhs);
Vector2f* res = new Vector2f(*lhs);
(*res) -= (*rhs);
LuaType<Vector2f>::push(L,res,true);
return 1;
}
int Vector2f__eq(lua_State* L)
{
Vector2f* lhs = LuaType<Vector2f>::check(L,1);
LUACHECKOBJ(lhs);
Vector2f* rhs = LuaType<Vector2f>::check(L,2);
LUACHECKOBJ(rhs);
lua_pushboolean(L, (*lhs) == (*rhs) ? 1 : 0);
return 1;
}
int Vector2fDotProduct(lua_State* L, Vector2f* obj)
{
Vector2f* rhs = LuaType<Vector2f>::check(L,1);
LUACHECKOBJ(rhs);
float res = obj->DotProduct(*rhs);
lua_pushnumber(L,res);
return 1;
}
int Vector2fNormalise(lua_State* L, Vector2f* obj)
{
Vector2f* res = new Vector2f();
(*res) = obj->Normalise();
LuaType<Vector2f>::push(L,res,true);
return 1;
}
int Vector2fRotate(lua_State* L, Vector2f* obj)
{
float num = (float)luaL_checknumber(L,1);
Vector2f* res = new Vector2f();
(*res) = obj->Rotate(num);
LuaType<Vector2f>::push(L,res,true);
return 1;
}
int Vector2fGetAttrx(lua_State*L)
{
Vector2f* self = LuaType<Vector2f>::check(L,1);
LUACHECKOBJ(self);
lua_pushnumber(L,self->x);
return 1;
}
int Vector2fGetAttry(lua_State*L)
{
Vector2f* self = LuaType<Vector2f>::check(L,1);
LUACHECKOBJ(self);
lua_pushnumber(L,self->y);
return 1;
}
int Vector2fGetAttrmagnitude(lua_State*L)
{
Vector2f* self = LuaType<Vector2f>::check(L,1);
LUACHECKOBJ(self);
lua_pushnumber(L,self->Magnitude());
return 1;
}
int Vector2fSetAttrx(lua_State*L)
{
Vector2f* self = LuaType<Vector2f>::check(L,1);
LUACHECKOBJ(self);
float value = (float)luaL_checknumber(L,2);
self->x = value;
return 0;
}
int Vector2fSetAttry(lua_State*L)
{
Vector2f* self = LuaType<Vector2f>::check(L,1);
LUACHECKOBJ(self);
float value = (float)luaL_checknumber(L,2);
self->y = value;
return 0;
}
RegType<Vector2f> Vector2fMethods[] =
{
LUAMETHOD(Vector2f,DotProduct)
LUAMETHOD(Vector2f,Normalise)
LUAMETHOD(Vector2f,Rotate)
{ NULL, NULL },
};
luaL_reg Vector2fGetters[]=
{
LUAGETTER(Vector2f,x)
LUAGETTER(Vector2f,y)
LUAGETTER(Vector2f,magnitude)
{ NULL, NULL },
};
luaL_reg Vector2fSetters[]=
{
LUASETTER(Vector2f,x)
LUASETTER(Vector2f,y)
{ NULL, NULL },
};
}
//setters
int DocumentSetAttrtitle(lua_State* L)
{
Document* doc = LuaType<Document>::check(L,1);
LUACHECKOBJ(doc);
const char* title = luaL_checkstring(L,2);
doc->SetTitle(title);
return 0;
}
RegType<Document> DocumentMethods[] =
{
LUAMETHOD(Document,PullToFront)
LUAMETHOD(Document,PushToBack)
LUAMETHOD(Document,Show)
LUAMETHOD(Document,Hide)
LUAMETHOD(Document,Close)
LUAMETHOD(Document,CreateElement)
LUAMETHOD(Document,CreateTextNode)
{ NULL, NULL },
};
luaL_Reg DocumentGetters[] =
{
LUAGETTER(Document,title)
LUAGETTER(Document,context)
{ NULL, NULL },
};
int Vector2fSetAttry(lua_State*L)
{
Vector2f* self = LuaType<Vector2f>::check(L,1);
LUACHECKOBJ(self);
float value = (float)luaL_checknumber(L,2);
self->y = value;
return 0;
}
RegType<Vector2f> Vector2fMethods[] =
{
LUAMETHOD(Vector2f,DotProduct)
LUAMETHOD(Vector2f,Normalise)
LUAMETHOD(Vector2f,Rotate)
{ NULL, NULL },
};
luaL_Reg Vector2fGetters[]=
{
LUAGETTER(Vector2f,x)
LUAGETTER(Vector2f,y)
LUAGETTER(Vector2f,magnitude)
{ NULL, NULL },
};
luaL_Reg Vector2fSetters[]=
{
