/*
** Lua binding: AtlasAdapters
** Generated automatically by tolua++-1.0.92 on Wed Nov 10 18:36:09 2010.
*/

#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "components/lua/tolua++.h"

/* Exported function */
TOLUA_API int  tolua_AtlasAdapters_open (lua_State* tolua_S);

#include "../../AdapterBase.h"
#include "../../AdapterFactory.h"
#include "../../StringAdapter.h"
#include "../../NumberAdapter.h"
#include "../../SizeAdapter.h"
#include "../../PolygonAdapter.h"
#include "../../AreaAdapter.h"
#include "../../TerrainModAdapter.h"
#include "../../MapAdapter.h"
#include "../../ListAdapter.h"
#include "../../PositionAdapter.h"
#include "../../Position2DAdapter.h"
#include "../../OrientationAdapter.h"
#include "../../StaticAdapter.h"

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__TerrainModAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter* self = (EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__PolygonAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::PolygonAdapter* self = (EmberOgre::Gui::Adapters::Atlas::PolygonAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__StaticAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::StaticAdapter* self = (EmberOgre::Gui::Adapters::Atlas::StaticAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__OrientationAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::OrientationAdapter* self = (EmberOgre::Gui::Adapters::Atlas::OrientationAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__SizeAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::SizeAdapter* self = (EmberOgre::Gui::Adapters::Atlas::SizeAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__MapAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::MapAdapter* self = (EmberOgre::Gui::Adapters::Atlas::MapAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_std__vector_std__string_ (lua_State* tolua_S)
{
 std::vector<std::string>* self = (std::vector<std::string>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_WFMath__Polygon_2_ (lua_State* tolua_S)
{
 WFMath::Polygon<2>* self = (WFMath::Polygon<2>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__ListAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::ListAdapter* self = (EmberOgre::Gui::Adapters::Atlas::ListAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__PositionAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::PositionAdapter* self = (EmberOgre::Gui::Adapters::Atlas::PositionAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__Position2DAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::Position2DAdapter* self = (EmberOgre::Gui::Adapters::Atlas::Position2DAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__NumberAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::NumberAdapter* self = (EmberOgre::Gui::Adapters::Atlas::NumberAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__AdapterFactory (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__StringAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::StringAdapter* self = (EmberOgre::Gui::Adapters::Atlas::StringAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__AdapterBase (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::AdapterBase* self = (EmberOgre::Gui::Adapters::Atlas::AdapterBase*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_EmberOgre__Gui__Adapters__Atlas__AreaAdapter (lua_State* tolua_S)
{
 EmberOgre::Gui::Adapters::Atlas::AreaAdapter* self = (EmberOgre::Gui::Adapters::Atlas::AreaAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"EmberOgre::EmberEntity");
 tolua_usertype(tolua_S,"::Atlas::Message::Element");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::SizeAdapter");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::ListAdapter");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::NumberAdapter");
 tolua_usertype(tolua_S,"CEGUI::Editbox");
 tolua_usertype(tolua_S,"Atlas::Message::MapType");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::AdapterBase");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::StaticAdapter");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::PositionAdapter");
 tolua_usertype(tolua_S,"CEGUI::Window");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::PolygonAdapter");
 tolua_usertype(tolua_S,"CEGUI::PushButton");
 tolua_usertype(tolua_S,"Eris::Entity");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::MapAdapter");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::AreaAdapter");
 tolua_usertype(tolua_S,"std::vector<std::string>");
 tolua_usertype(tolua_S,"WFMath::Polygon<2>");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::OrientationAdapter");
 tolua_usertype(tolua_S,"CEGUI::Combobox");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::Position2DAdapter");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory");
 tolua_usertype(tolua_S,"sigc::signal<void>");
 tolua_usertype(tolua_S,"EmberOgre::Gui::Adapters::Atlas::StringAdapter");
 tolua_usertype(tolua_S,"Atlas::Message::Element");
 tolua_usertype(tolua_S,"CEGUI::Slider");
}

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::AdapterBase */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterBase* self = (EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setValue of class  EmberOgre::Gui::Adapters::Atlas::AdapterBase */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_setValue00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_setValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterBase",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterBase* self = (EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  tolua_tousertype(tolua_S,1,0);
  Atlas::Message::Element* element = ((Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValue'", NULL);
#endif
  {
   self->setValue(*element);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getValue of class  EmberOgre::Gui::Adapters::Atlas::AdapterBase */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_getValue00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_getValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterBase* self = (EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValue'", NULL);
#endif
  {
   Atlas::Message::Element& tolua_ret = (Atlas::Message::Element&)  self->getValue();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Atlas::Message::Element");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOriginalValue of class  EmberOgre::Gui::Adapters::Atlas::AdapterBase */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_getOriginalValue00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_getOriginalValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Adapters::Atlas::AdapterBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Adapters::Atlas::AdapterBase* self = (const EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOriginalValue'", NULL);
#endif
  {
   const Atlas::Message::Element& tolua_ret = (const Atlas::Message::Element&)  self->getOriginalValue();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Atlas::Message::Element");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOriginalValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventValueChanged of class  EmberOgre::Gui::Adapters::Atlas::AdapterBase */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__Adapters__Atlas__AdapterBase_EventValueChanged
static int tolua_get_EmberOgre__Gui__Adapters__Atlas__AdapterBase_EventValueChanged(lua_State* tolua_S)
{
  EmberOgre::Gui::Adapters::Atlas::AdapterBase* self = (EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventValueChanged'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventValueChanged,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventValueChanged of class  EmberOgre::Gui::Adapters::Atlas::AdapterBase */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__Adapters__Atlas__AdapterBase_EventValueChanged
static int tolua_set_EmberOgre__Gui__Adapters__Atlas__AdapterBase_EventValueChanged(lua_State* tolua_S)
{
  EmberOgre::Gui::Adapters::Atlas::AdapterBase* self = (EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventValueChanged'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventValueChanged = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: updateGui of class  EmberOgre::Gui::Adapters::Atlas::AdapterBase */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_updateGui00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_updateGui00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterBase",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterBase* self = (EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  tolua_tousertype(tolua_S,1,0);
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'updateGui'", NULL);
#endif
  {
   self->updateGui(*element);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'updateGui'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hasChanges of class  EmberOgre::Gui::Adapters::Atlas::AdapterBase */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_hasChanges00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_hasChanges00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterBase* self = (EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hasChanges'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->hasChanges();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hasChanges'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: remove of class  EmberOgre::Gui::Adapters::Atlas::AdapterBase */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_remove00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_remove00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterBase* self = (EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'remove'", NULL);
#endif
  {
   self->remove();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'remove'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isRemoved of class  EmberOgre::Gui::Adapters::Atlas::AdapterBase */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_isRemoved00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_isRemoved00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Adapters::Atlas::AdapterBase",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Adapters::Atlas::AdapterBase* self = (const EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isRemoved'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isRemoved();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isRemoved'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addSuggestion of class  EmberOgre::Gui::Adapters::Atlas::AdapterBase */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_addSuggestion00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_addSuggestion00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterBase",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterBase* self = (EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  tolua_tousertype(tolua_S,1,0);
  const std::string suggestedValue = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addSuggestion'", NULL);
#endif
  {
   self->addSuggestion(suggestedValue);
   tolua_pushcppstring(tolua_S,(const char*)suggestedValue);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addSuggestion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_new00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string prefix = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   EmberOgre::Gui::Adapters::Atlas::AdapterFactory* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::AdapterFactory)(prefix));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_new00_local
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string prefix = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   EmberOgre::Gui::Adapters::Atlas::AdapterFactory* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::AdapterFactory)(prefix));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createStringAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createStringAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createStringAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createStringAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::StringAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::StringAdapter*)  self->createStringAdapter(container,adapterPrefix,*element);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::StringAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createStringAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createNumberAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createNumberAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createNumberAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createNumberAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::NumberAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::NumberAdapter*)  self->createNumberAdapter(container,adapterPrefix,*element);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::NumberAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createNumberAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createSizeAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createSizeAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createSizeAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createSizeAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::SizeAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::SizeAdapter*)  self->createSizeAdapter(container,adapterPrefix,*element);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::SizeAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createSizeAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createPositionAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createPositionAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createPositionAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createPositionAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::PositionAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::PositionAdapter*)  self->createPositionAdapter(container,adapterPrefix,*element);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::PositionAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createPositionAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createPosition2DAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createPosition2DAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createPosition2DAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createPosition2DAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::Position2DAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::Position2DAdapter*)  self->createPosition2DAdapter(container,adapterPrefix,*element);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::Position2DAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createPosition2DAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createMapAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createMapAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createMapAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createMapAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::MapAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  self->createMapAdapter(container,adapterPrefix,*element);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::MapAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createMapAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createMapAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createMapAdapter01
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createMapAdapter01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Atlas::Message::MapType",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const Atlas::Message::MapType attributes = *((const Atlas::Message::MapType*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createMapAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::MapAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  self->createMapAdapter(container,adapterPrefix,attributes);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::MapAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
tolua_lerror:
 return tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createMapAdapter00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: createMapAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createMapAdapter02
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createMapAdapter02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"Eris::Entity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createMapAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::MapAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  self->createMapAdapter(container,adapterPrefix,entity);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::MapAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
tolua_lerror:
 return tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createMapAdapter01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: createListAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createListAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createListAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createListAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::ListAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::ListAdapter*)  self->createListAdapter(container,adapterPrefix,*element);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::ListAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createListAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createOrientationAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createOrientationAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createOrientationAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createOrientationAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::OrientationAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::OrientationAdapter*)  self->createOrientationAdapter(container,adapterPrefix,*element);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::OrientationAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createOrientationAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createStaticAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createStaticAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createStaticAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createStaticAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::StaticAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::StaticAdapter*)  self->createStaticAdapter(container,adapterPrefix,*element);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::StaticAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createStaticAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createAreaAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createAreaAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createAreaAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,5,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,4,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createAreaAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::AreaAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::AreaAdapter*)  self->createAreaAdapter(container,adapterPrefix,*element,entity);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::AreaAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createAreaAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createPolygonAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createPolygonAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createPolygonAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,5,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,4,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createPolygonAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::PolygonAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::PolygonAdapter*)  self->createPolygonAdapter(container,adapterPrefix,*element,entity);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::PolygonAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createPolygonAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createTerrainModAdapter of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createTerrainModAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createTerrainModAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,5,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,4,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createTerrainModAdapter'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter*)  self->createTerrainModAdapter(container,adapterPrefix,*element,entity);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createTerrainModAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createAdapterByType of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createAdapterByType00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createAdapterByType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,6,"EmberOgre::EmberEntity",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  std::string type = ((std::string)  tolua_tocppstring(tolua_S,2,0));
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,5,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createAdapterByType'", NULL);
#endif
  {
   EmberOgre::Gui::Adapters::Atlas::AdapterBase* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  self->createAdapterByType(type,container,adapterPrefix,*element,entity);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::AdapterBase");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createAdapterByType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: loadLayoutIntoContainer of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_loadLayoutIntoContainer00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_loadLayoutIntoContainer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* container = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const std::string adapterPrefix = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const std::string layoutfile = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadLayoutIntoContainer'", NULL);
#endif
  {
   CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->loadLayoutIntoContainer(container,adapterPrefix,layoutfile);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
   tolua_pushcppstring(tolua_S,(const char*)adapterPrefix);
   tolua_pushcppstring(tolua_S,(const char*)layoutfile);
  }
 }
 return 3;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadLayoutIntoContainer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentPrefix of class  EmberOgre::Gui::Adapters::Atlas::AdapterFactory */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_getCurrentPrefix00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_getCurrentPrefix00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Adapters::Atlas::AdapterFactory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Adapters::Atlas::AdapterFactory* self = (const EmberOgre::Gui::Adapters::Atlas::AdapterFactory*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentPrefix'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getCurrentPrefix();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCurrentPrefix'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Atlas::StringAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StringAdapter_new00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StringAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::StringAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Combobox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Combobox* textWindow = ((CEGUI::Combobox*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Atlas::StringAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::StringAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::StringAdapter)(*element,textWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::StringAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Atlas::StringAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StringAdapter_new00_local
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StringAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::StringAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Combobox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Combobox* textWindow = ((CEGUI::Combobox*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Atlas::StringAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::StringAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::StringAdapter)(*element,textWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::StringAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::StringAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StringAdapter_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StringAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::StringAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::StringAdapter* self = (EmberOgre::Gui::Adapters::Atlas::StringAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Atlas::NumberAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_NumberAdapter_new00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_NumberAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::NumberAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Combobox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Combobox* textWindow = ((CEGUI::Combobox*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Atlas::NumberAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::NumberAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::NumberAdapter)(*element,textWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::NumberAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Atlas::NumberAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_NumberAdapter_new00_local
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_NumberAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::NumberAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Combobox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Combobox* textWindow = ((CEGUI::Combobox*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Atlas::NumberAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::NumberAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::NumberAdapter)(*element,textWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::NumberAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::NumberAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_NumberAdapter_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_NumberAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::NumberAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::NumberAdapter* self = (EmberOgre::Gui::Adapters::Atlas::NumberAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Atlas::SizeAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_SizeAdapter_new00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_SizeAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::SizeAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,7,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,8,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,9,"CEGUI::Slider",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,10,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,11,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* lowerXWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* lowerYWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Window* lowerZWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,5,0));
  CEGUI::Window* upperXWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,6,0));
  CEGUI::Window* upperYWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,7,0));
  CEGUI::Window* upperZWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,8,0));
  CEGUI::Slider* scaler = ((CEGUI::Slider*)  tolua_tousertype(tolua_S,9,0));
  CEGUI::Window* infoWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,10,0));
  {
   EmberOgre::Gui::Adapters::Atlas::SizeAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::SizeAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::SizeAdapter)(*element,lowerXWindow,lowerYWindow,lowerZWindow,upperXWindow,upperYWindow,upperZWindow,scaler,infoWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::SizeAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Atlas::SizeAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_SizeAdapter_new00_local
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_SizeAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::SizeAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,7,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,8,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,9,"CEGUI::Slider",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,10,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,11,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* lowerXWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* lowerYWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Window* lowerZWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,5,0));
  CEGUI::Window* upperXWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,6,0));
  CEGUI::Window* upperYWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,7,0));
  CEGUI::Window* upperZWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,8,0));
  CEGUI::Slider* scaler = ((CEGUI::Slider*)  tolua_tousertype(tolua_S,9,0));
  CEGUI::Window* infoWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,10,0));
  {
   EmberOgre::Gui::Adapters::Atlas::SizeAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::SizeAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::SizeAdapter)(*element,lowerXWindow,lowerYWindow,lowerZWindow,upperXWindow,upperYWindow,upperZWindow,scaler,infoWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::SizeAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::SizeAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_SizeAdapter_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_SizeAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::SizeAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::SizeAdapter* self = (EmberOgre::Gui::Adapters::Atlas::SizeAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Atlas::PolygonAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_new00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::PolygonAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const ::Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::PushButton",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const ::Atlas::Message::Element* element = ((const ::Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::PushButton* showButton = ((CEGUI::PushButton*)  tolua_tousertype(tolua_S,3,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,4,0));
  {
   EmberOgre::Gui::Adapters::Atlas::PolygonAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::PolygonAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::PolygonAdapter)(*element,showButton,entity));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::PolygonAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Atlas::PolygonAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_new00_local
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::PolygonAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const ::Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::PushButton",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const ::Atlas::Message::Element* element = ((const ::Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::PushButton* showButton = ((CEGUI::PushButton*)  tolua_tousertype(tolua_S,3,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,4,0));
  {
   EmberOgre::Gui::Adapters::Atlas::PolygonAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::PolygonAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::PolygonAdapter)(*element,showButton,entity));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::PolygonAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::PolygonAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::PolygonAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::PolygonAdapter* self = (EmberOgre::Gui::Adapters::Atlas::PolygonAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toggleDisplayOfPolygon of class  EmberOgre::Gui::Adapters::Atlas::PolygonAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_toggleDisplayOfPolygon00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_toggleDisplayOfPolygon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::PolygonAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::PolygonAdapter* self = (EmberOgre::Gui::Adapters::Atlas::PolygonAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toggleDisplayOfPolygon'", NULL);
#endif
  {
   self->toggleDisplayOfPolygon();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toggleDisplayOfPolygon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createNewPolygon of class  EmberOgre::Gui::Adapters::Atlas::PolygonAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_createNewPolygon00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_createNewPolygon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::PolygonAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::PolygonAdapter* self = (EmberOgre::Gui::Adapters::Atlas::PolygonAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createNewPolygon'", NULL);
#endif
  {
   self->createNewPolygon();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createNewPolygon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hasShape of class  EmberOgre::Gui::Adapters::Atlas::PolygonAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_hasShape00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_hasShape00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Adapters::Atlas::PolygonAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Adapters::Atlas::PolygonAdapter* self = (const EmberOgre::Gui::Adapters::Atlas::PolygonAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hasShape'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->hasShape();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hasShape'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getShape of class  EmberOgre::Gui::Adapters::Atlas::PolygonAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_getShape00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_getShape00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Adapters::Atlas::PolygonAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Adapters::Atlas::PolygonAdapter* self = (const EmberOgre::Gui::Adapters::Atlas::PolygonAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getShape'", NULL);
#endif
  {
   const WFMath::Polygon<2> tolua_ret = (const WFMath::Polygon<2>)  self->getShape();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((WFMath::Polygon<2>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"const WFMath::Polygon<2>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(const WFMath::Polygon<2>));
     tolua_pushusertype(tolua_S,tolua_obj,"const WFMath::Polygon<2>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getShape'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Atlas::AreaAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_new00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AreaAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::PushButton",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Combobox",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::PushButton* showButton = ((CEGUI::PushButton*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Combobox* layerWindow = ((CEGUI::Combobox*)  tolua_tousertype(tolua_S,4,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,5,0));
  {
   EmberOgre::Gui::Adapters::Atlas::AreaAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::AreaAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::AreaAdapter)(*element,showButton,layerWindow,entity));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::AreaAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Atlas::AreaAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_new00_local
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AreaAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::PushButton",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Combobox",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::PushButton* showButton = ((CEGUI::PushButton*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Combobox* layerWindow = ((CEGUI::Combobox*)  tolua_tousertype(tolua_S,4,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,5,0));
  {
   EmberOgre::Gui::Adapters::Atlas::AreaAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::AreaAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::AreaAdapter)(*element,showButton,layerWindow,entity));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::AreaAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::AreaAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AreaAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AreaAdapter* self = (EmberOgre::Gui::Adapters::Atlas::AreaAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toggleDisplayOfPolygon of class  EmberOgre::Gui::Adapters::Atlas::AreaAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_toggleDisplayOfPolygon00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_toggleDisplayOfPolygon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AreaAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AreaAdapter* self = (EmberOgre::Gui::Adapters::Atlas::AreaAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toggleDisplayOfPolygon'", NULL);
#endif
  {
   self->toggleDisplayOfPolygon();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toggleDisplayOfPolygon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addAreaSuggestion of class  EmberOgre::Gui::Adapters::Atlas::AreaAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_addAreaSuggestion00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_addAreaSuggestion00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AreaAdapter",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AreaAdapter* self = (EmberOgre::Gui::Adapters::Atlas::AreaAdapter*)  tolua_tousertype(tolua_S,1,0);
  int id = ((int)  tolua_tonumber(tolua_S,2,0));
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addAreaSuggestion'", NULL);
#endif
  {
   self->addAreaSuggestion(id,name);
   tolua_pushcppstring(tolua_S,(const char*)name);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addAreaSuggestion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearAreaSuggestions of class  EmberOgre::Gui::Adapters::Atlas::AreaAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_clearAreaSuggestions00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_clearAreaSuggestions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::AreaAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::AreaAdapter* self = (EmberOgre::Gui::Adapters::Atlas::AreaAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearAreaSuggestions'", NULL);
#endif
  {
   self->clearAreaSuggestions();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearAreaSuggestions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_TerrainModAdapter_new00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_TerrainModAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::PushButton",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Combobox",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"CEGUI::Combobox",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,7,"CEGUI::Editbox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::PushButton* showButton = ((CEGUI::PushButton*)  tolua_tousertype(tolua_S,3,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Combobox* posTypeCombobox = ((CEGUI::Combobox*)  tolua_tousertype(tolua_S,5,0));
  CEGUI::Combobox* modTypeCombobox = ((CEGUI::Combobox*)  tolua_tousertype(tolua_S,6,0));
  CEGUI::Editbox* heightTextbox = ((CEGUI::Editbox*)  tolua_tousertype(tolua_S,7,0));
  {
   EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter)(*element,showButton,entity,posTypeCombobox,modTypeCombobox,heightTextbox));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_TerrainModAdapter_new00_local
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_TerrainModAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::PushButton",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"EmberOgre::EmberEntity",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Combobox",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"CEGUI::Combobox",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,7,"CEGUI::Editbox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::PushButton* showButton = ((CEGUI::PushButton*)  tolua_tousertype(tolua_S,3,0));
  EmberOgre::EmberEntity* entity = ((EmberOgre::EmberEntity*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Combobox* posTypeCombobox = ((CEGUI::Combobox*)  tolua_tousertype(tolua_S,5,0));
  CEGUI::Combobox* modTypeCombobox = ((CEGUI::Combobox*)  tolua_tousertype(tolua_S,6,0));
  CEGUI::Editbox* heightTextbox = ((CEGUI::Editbox*)  tolua_tousertype(tolua_S,7,0));
  {
   EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter)(*element,showButton,entity,posTypeCombobox,modTypeCombobox,heightTextbox));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_TerrainModAdapter_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_TerrainModAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter* self = (EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: updateGui of class  EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_TerrainModAdapter_updateGui00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_TerrainModAdapter_updateGui00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const ::Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter* self = (EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter*)  tolua_tousertype(tolua_S,1,0);
  const ::Atlas::Message::Element* element = ((const ::Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'updateGui'", NULL);
#endif
  {
   self->updateGui(*element);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'updateGui'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Atlas::MapAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_new00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::MapAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const ::Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const ::Atlas::Message::Element* element = ((const ::Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* childContainer = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Atlas::MapAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::MapAdapter)(*element,childContainer));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::MapAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Atlas::MapAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_new00_local
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::MapAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const ::Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const ::Atlas::Message::Element* element = ((const ::Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* childContainer = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Atlas::MapAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::MapAdapter)(*element,childContainer));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::MapAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::MapAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::MapAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::MapAdapter* self = (EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAttributeNames of class  EmberOgre::Gui::Adapters::Atlas::MapAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_getAttributeNames00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_getAttributeNames00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::MapAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::MapAdapter* self = (EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAttributeNames'", NULL);
#endif
  {
   std::vector<std::string> tolua_ret = (std::vector<std::string>)  self->getAttributeNames();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<std::string>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<std::string>));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAttributeNames'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: valueOfAttr of class  EmberOgre::Gui::Adapters::Atlas::MapAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_valueOfAttr00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_valueOfAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Adapters::Atlas::MapAdapter",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Adapters::Atlas::MapAdapter* self = (const EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  tolua_tousertype(tolua_S,1,0);
  const std::string attr = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'valueOfAttr'", NULL);
#endif
  {
   const Atlas::Message::Element& tolua_ret = (const Atlas::Message::Element&)  self->valueOfAttr(attr);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Atlas::Message::Element");
   tolua_pushcppstring(tolua_S,(const char*)attr);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'valueOfAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hasAttr of class  EmberOgre::Gui::Adapters::Atlas::MapAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_hasAttr00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_hasAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Adapters::Atlas::MapAdapter",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Adapters::Atlas::MapAdapter* self = (const EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  tolua_tousertype(tolua_S,1,0);
  const std::string attr = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hasAttr'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->hasAttr(attr);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)attr);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hasAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addAttributeAdapter of class  EmberOgre::Gui::Adapters::Atlas::MapAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_addAttributeAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_addAttributeAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::MapAdapter",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"EmberOgre::Gui::Adapters::Atlas::AdapterBase",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::MapAdapter* self = (EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  tolua_tousertype(tolua_S,1,0);
  const std::string attributeName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  EmberOgre::Gui::Adapters::Atlas::AdapterBase* adapter = ((EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* containerWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addAttributeAdapter'", NULL);
#endif
  {
   self->addAttributeAdapter(attributeName,adapter,containerWindow);
   tolua_pushcppstring(tolua_S,(const char*)attributeName);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addAttributeAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeAdapters of class  EmberOgre::Gui::Adapters::Atlas::MapAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_removeAdapters00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_removeAdapters00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::MapAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::MapAdapter* self = (EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeAdapters'", NULL);
#endif
  {
   self->removeAdapters();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeAdapters'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hasAdapter of class  EmberOgre::Gui::Adapters::Atlas::MapAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_hasAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_hasAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Adapters::Atlas::MapAdapter",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Adapters::Atlas::MapAdapter* self = (const EmberOgre::Gui::Adapters::Atlas::MapAdapter*)  tolua_tousertype(tolua_S,1,0);
  const std::string attr = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hasAdapter'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->hasAdapter(attr);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)attr);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hasAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Atlas::ListAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_new00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::ListAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* childContainer = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Atlas::ListAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::ListAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::ListAdapter)(*element,childContainer));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::ListAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Atlas::ListAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_new00_local
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::ListAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* childContainer = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Atlas::ListAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::ListAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::ListAdapter)(*element,childContainer));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::ListAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::ListAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::ListAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::ListAdapter* self = (EmberOgre::Gui::Adapters::Atlas::ListAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSize of class  EmberOgre::Gui::Adapters::Atlas::ListAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_getSize00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_getSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::ListAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::ListAdapter* self = (EmberOgre::Gui::Adapters::Atlas::ListAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSize'", NULL);
#endif
  {
   int tolua_ret = (int)  self->getSize();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: valueOfAttr of class  EmberOgre::Gui::Adapters::Atlas::ListAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_valueOfAttr00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_valueOfAttr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const EmberOgre::Gui::Adapters::Atlas::ListAdapter",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const EmberOgre::Gui::Adapters::Atlas::ListAdapter* self = (const EmberOgre::Gui::Adapters::Atlas::ListAdapter*)  tolua_tousertype(tolua_S,1,0);
  int index = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'valueOfAttr'", NULL);
#endif
  {
   const Atlas::Message::Element& tolua_ret = (const Atlas::Message::Element&)  self->valueOfAttr(index);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Atlas::Message::Element");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'valueOfAttr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addAttributeAdapter of class  EmberOgre::Gui::Adapters::Atlas::ListAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_addAttributeAdapter00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_addAttributeAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::ListAdapter",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"EmberOgre::Gui::Adapters::Atlas::AdapterBase",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::ListAdapter* self = (EmberOgre::Gui::Adapters::Atlas::ListAdapter*)  tolua_tousertype(tolua_S,1,0);
  EmberOgre::Gui::Adapters::Atlas::AdapterBase* adapter = ((EmberOgre::Gui::Adapters::Atlas::AdapterBase*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* containerWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addAttributeAdapter'", NULL);
#endif
  {
   self->addAttributeAdapter(adapter,containerWindow);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addAttributeAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeAdapters of class  EmberOgre::Gui::Adapters::Atlas::ListAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_removeAdapters00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_removeAdapters00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::ListAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::ListAdapter* self = (EmberOgre::Gui::Adapters::Atlas::ListAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeAdapters'", NULL);
#endif
  {
   self->removeAdapters();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeAdapters'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Atlas::PositionAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PositionAdapter_new00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PositionAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::PositionAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const ::Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"CEGUI::PushButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const ::Atlas::Message::Element* element = ((const ::Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,5,0));
  CEGUI::PushButton* moveButton = ((CEGUI::PushButton*)  tolua_tousertype(tolua_S,6,0));
  {
   EmberOgre::Gui::Adapters::Atlas::PositionAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::PositionAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::PositionAdapter)(*element,xWindow,yWindow,zWindow,moveButton));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::PositionAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Atlas::PositionAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PositionAdapter_new00_local
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PositionAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::PositionAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const ::Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"CEGUI::PushButton",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const ::Atlas::Message::Element* element = ((const ::Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,5,0));
  CEGUI::PushButton* moveButton = ((CEGUI::PushButton*)  tolua_tousertype(tolua_S,6,0));
  {
   EmberOgre::Gui::Adapters::Atlas::PositionAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::PositionAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::PositionAdapter)(*element,xWindow,yWindow,zWindow,moveButton));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::PositionAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::PositionAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PositionAdapter_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PositionAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::PositionAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::PositionAdapter* self = (EmberOgre::Gui::Adapters::Atlas::PositionAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventMoveClicked of class  EmberOgre::Gui::Adapters::Atlas::PositionAdapter */
#ifndef TOLUA_DISABLE_tolua_get_EmberOgre__Gui__Adapters__Atlas__PositionAdapter_EventMoveClicked
static int tolua_get_EmberOgre__Gui__Adapters__Atlas__PositionAdapter_EventMoveClicked(lua_State* tolua_S)
{
  EmberOgre::Gui::Adapters::Atlas::PositionAdapter* self = (EmberOgre::Gui::Adapters::Atlas::PositionAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMoveClicked'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventMoveClicked,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventMoveClicked of class  EmberOgre::Gui::Adapters::Atlas::PositionAdapter */
#ifndef TOLUA_DISABLE_tolua_set_EmberOgre__Gui__Adapters__Atlas__PositionAdapter_EventMoveClicked
static int tolua_set_EmberOgre__Gui__Adapters__Atlas__PositionAdapter_EventMoveClicked(lua_State* tolua_S)
{
  EmberOgre::Gui::Adapters::Atlas::PositionAdapter* self = (EmberOgre::Gui::Adapters::Atlas::PositionAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMoveClicked'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventMoveClicked = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Atlas::Position2DAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_Position2DAdapter_new00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_Position2DAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::Position2DAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const ::Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const ::Atlas::Message::Element* element = ((const ::Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  {
   EmberOgre::Gui::Adapters::Atlas::Position2DAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::Position2DAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::Position2DAdapter)(*element,xWindow,yWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::Position2DAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Atlas::Position2DAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_Position2DAdapter_new00_local
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_Position2DAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::Position2DAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const ::Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const ::Atlas::Message::Element* element = ((const ::Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  {
   EmberOgre::Gui::Adapters::Atlas::Position2DAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::Position2DAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::Position2DAdapter)(*element,xWindow,yWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::Position2DAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::Position2DAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_Position2DAdapter_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_Position2DAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::Position2DAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::Position2DAdapter* self = (EmberOgre::Gui::Adapters::Atlas::Position2DAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Atlas::OrientationAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_OrientationAdapter_new00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_OrientationAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::OrientationAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,5,0));
  CEGUI::Window* scalarWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,6,0));
  {
   EmberOgre::Gui::Adapters::Atlas::OrientationAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::OrientationAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::OrientationAdapter)(*element,xWindow,yWindow,zWindow,scalarWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::OrientationAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Atlas::OrientationAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_OrientationAdapter_new00_local
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_OrientationAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::OrientationAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Atlas::Message::Element* element = ((const Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* xWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Window* yWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::Window* zWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,5,0));
  CEGUI::Window* scalarWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,6,0));
  {
   EmberOgre::Gui::Adapters::Atlas::OrientationAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::OrientationAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::OrientationAdapter)(*element,xWindow,yWindow,zWindow,scalarWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::OrientationAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::OrientationAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_OrientationAdapter_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_OrientationAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::OrientationAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::OrientationAdapter* self = (EmberOgre::Gui::Adapters::Atlas::OrientationAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  EmberOgre::Gui::Adapters::Atlas::StaticAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StaticAdapter_new00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StaticAdapter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::StaticAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const ::Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const ::Atlas::Message::Element* element = ((const ::Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* textWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Atlas::StaticAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::StaticAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::StaticAdapter)(*element,textWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::StaticAdapter");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  EmberOgre::Gui::Adapters::Atlas::StaticAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StaticAdapter_new00_local
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StaticAdapter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::StaticAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const ::Atlas::Message::Element",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const ::Atlas::Message::Element* element = ((const ::Atlas::Message::Element*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* textWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
  {
   EmberOgre::Gui::Adapters::Atlas::StaticAdapter* tolua_ret = (EmberOgre::Gui::Adapters::Atlas::StaticAdapter*)  Mtolua_new((EmberOgre::Gui::Adapters::Atlas::StaticAdapter)(*element,textWindow));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"EmberOgre::Gui::Adapters::Atlas::StaticAdapter");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  EmberOgre::Gui::Adapters::Atlas::StaticAdapter */
#ifndef TOLUA_DISABLE_tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StaticAdapter_delete00
static int tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StaticAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"EmberOgre::Gui::Adapters::Atlas::StaticAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EmberOgre::Gui::Adapters::Atlas::StaticAdapter* self = (EmberOgre::Gui::Adapters::Atlas::StaticAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_AtlasAdapters_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"AdapterBase","EmberOgre::Gui::Adapters::Atlas::AdapterBase","",tolua_collect_EmberOgre__Gui__Adapters__Atlas__AdapterBase);
      #else
      tolua_cclass(tolua_S,"AdapterBase","EmberOgre::Gui::Adapters::Atlas::AdapterBase","",NULL);
      #endif
      tolua_beginmodule(tolua_S,"AdapterBase");
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_delete00);
       tolua_function(tolua_S,"setValue",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_setValue00);
       tolua_function(tolua_S,"getValue",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_getValue00);
       tolua_function(tolua_S,"getOriginalValue",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_getOriginalValue00);
       tolua_variable(tolua_S,"EventValueChanged",tolua_get_EmberOgre__Gui__Adapters__Atlas__AdapterBase_EventValueChanged,tolua_set_EmberOgre__Gui__Adapters__Atlas__AdapterBase_EventValueChanged);
       tolua_function(tolua_S,"updateGui",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_updateGui00);
       tolua_function(tolua_S,"hasChanges",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_hasChanges00);
       tolua_function(tolua_S,"remove",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_remove00);
       tolua_function(tolua_S,"isRemoved",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_isRemoved00);
       tolua_function(tolua_S,"addSuggestion",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterBase_addSuggestion00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_cclass(tolua_S,"EmberEntity","EmberOgre::EmberEntity","",NULL);
   tolua_beginmodule(tolua_S,"EmberEntity");
   tolua_endmodule(tolua_S);
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"AdapterFactory","EmberOgre::Gui::Adapters::Atlas::AdapterFactory","",tolua_collect_EmberOgre__Gui__Adapters__Atlas__AdapterFactory);
      #else
      tolua_cclass(tolua_S,"AdapterFactory","EmberOgre::Gui::Adapters::Atlas::AdapterFactory","",NULL);
      #endif
      tolua_beginmodule(tolua_S,"AdapterFactory");
       tolua_function(tolua_S,"new",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_new00);
       tolua_function(tolua_S,"new_local",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_new00_local);
       tolua_function(tolua_S,".call",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_new00_local);
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_delete00);
       tolua_function(tolua_S,"createStringAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createStringAdapter00);
       tolua_function(tolua_S,"createNumberAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createNumberAdapter00);
       tolua_function(tolua_S,"createSizeAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createSizeAdapter00);
       tolua_function(tolua_S,"createPositionAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createPositionAdapter00);
       tolua_function(tolua_S,"createPosition2DAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createPosition2DAdapter00);
       tolua_function(tolua_S,"createMapAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createMapAdapter00);
       tolua_function(tolua_S,"createMapAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createMapAdapter01);
       tolua_function(tolua_S,"createMapAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createMapAdapter02);
       tolua_function(tolua_S,"createListAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createListAdapter00);
       tolua_function(tolua_S,"createOrientationAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createOrientationAdapter00);
       tolua_function(tolua_S,"createStaticAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createStaticAdapter00);
       tolua_function(tolua_S,"createAreaAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createAreaAdapter00);
       tolua_function(tolua_S,"createPolygonAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createPolygonAdapter00);
       tolua_function(tolua_S,"createTerrainModAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createTerrainModAdapter00);
       tolua_function(tolua_S,"createAdapterByType",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_createAdapterByType00);
       tolua_function(tolua_S,"loadLayoutIntoContainer",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_loadLayoutIntoContainer00);
       tolua_function(tolua_S,"getCurrentPrefix",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AdapterFactory_getCurrentPrefix00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"StringAdapter","EmberOgre::Gui::Adapters::Atlas::StringAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",tolua_collect_EmberOgre__Gui__Adapters__Atlas__StringAdapter);
      #else
      tolua_cclass(tolua_S,"StringAdapter","EmberOgre::Gui::Adapters::Atlas::StringAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",NULL);
      #endif
      tolua_beginmodule(tolua_S,"StringAdapter");
       tolua_function(tolua_S,"new",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StringAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StringAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StringAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StringAdapter_delete00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"NumberAdapter","EmberOgre::Gui::Adapters::Atlas::NumberAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",tolua_collect_EmberOgre__Gui__Adapters__Atlas__NumberAdapter);
      #else
      tolua_cclass(tolua_S,"NumberAdapter","EmberOgre::Gui::Adapters::Atlas::NumberAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",NULL);
      #endif
      tolua_beginmodule(tolua_S,"NumberAdapter");
       tolua_function(tolua_S,"new",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_NumberAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_NumberAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_NumberAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_NumberAdapter_delete00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"SizeAdapter","EmberOgre::Gui::Adapters::Atlas::SizeAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",tolua_collect_EmberOgre__Gui__Adapters__Atlas__SizeAdapter);
      #else
      tolua_cclass(tolua_S,"SizeAdapter","EmberOgre::Gui::Adapters::Atlas::SizeAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",NULL);
      #endif
      tolua_beginmodule(tolua_S,"SizeAdapter");
       tolua_function(tolua_S,"new",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_SizeAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_SizeAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_SizeAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_SizeAdapter_delete00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"PolygonAdapter","EmberOgre::Gui::Adapters::Atlas::PolygonAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",tolua_collect_EmberOgre__Gui__Adapters__Atlas__PolygonAdapter);
      #else
      tolua_cclass(tolua_S,"PolygonAdapter","EmberOgre::Gui::Adapters::Atlas::PolygonAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",NULL);
      #endif
      tolua_beginmodule(tolua_S,"PolygonAdapter");
       tolua_function(tolua_S,"new",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_delete00);
       tolua_function(tolua_S,"toggleDisplayOfPolygon",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_toggleDisplayOfPolygon00);
       tolua_function(tolua_S,"createNewPolygon",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_createNewPolygon00);
       tolua_function(tolua_S,"hasShape",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_hasShape00);
       tolua_function(tolua_S,"getShape",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PolygonAdapter_getShape00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"AreaAdapter","EmberOgre::Gui::Adapters::Atlas::AreaAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",tolua_collect_EmberOgre__Gui__Adapters__Atlas__AreaAdapter);
      #else
      tolua_cclass(tolua_S,"AreaAdapter","EmberOgre::Gui::Adapters::Atlas::AreaAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",NULL);
      #endif
      tolua_beginmodule(tolua_S,"AreaAdapter");
       tolua_function(tolua_S,"new",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_delete00);
       tolua_function(tolua_S,"toggleDisplayOfPolygon",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_toggleDisplayOfPolygon00);
       tolua_function(tolua_S,"addAreaSuggestion",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_addAreaSuggestion00);
       tolua_function(tolua_S,"clearAreaSuggestions",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_AreaAdapter_clearAreaSuggestions00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"TerrainModAdapter","EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",tolua_collect_EmberOgre__Gui__Adapters__Atlas__TerrainModAdapter);
      #else
      tolua_cclass(tolua_S,"TerrainModAdapter","EmberOgre::Gui::Adapters::Atlas::TerrainModAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",NULL);
      #endif
      tolua_beginmodule(tolua_S,"TerrainModAdapter");
       tolua_function(tolua_S,"new",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_TerrainModAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_TerrainModAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_TerrainModAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_TerrainModAdapter_delete00);
       tolua_function(tolua_S,"updateGui",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_TerrainModAdapter_updateGui00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"MapAdapter","EmberOgre::Gui::Adapters::Atlas::MapAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",tolua_collect_EmberOgre__Gui__Adapters__Atlas__MapAdapter);
      #else
      tolua_cclass(tolua_S,"MapAdapter","EmberOgre::Gui::Adapters::Atlas::MapAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",NULL);
      #endif
      tolua_beginmodule(tolua_S,"MapAdapter");
       tolua_function(tolua_S,"new",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_delete00);
       tolua_function(tolua_S,"getAttributeNames",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_getAttributeNames00);
       tolua_function(tolua_S,"valueOfAttr",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_valueOfAttr00);
       tolua_function(tolua_S,"hasAttr",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_hasAttr00);
       tolua_function(tolua_S,"addAttributeAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_addAttributeAdapter00);
       tolua_function(tolua_S,"removeAdapters",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_removeAdapters00);
       tolua_function(tolua_S,"hasAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_MapAdapter_hasAdapter00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"ListAdapter","EmberOgre::Gui::Adapters::Atlas::ListAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",tolua_collect_EmberOgre__Gui__Adapters__Atlas__ListAdapter);
      #else
      tolua_cclass(tolua_S,"ListAdapter","EmberOgre::Gui::Adapters::Atlas::ListAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",NULL);
      #endif
      tolua_beginmodule(tolua_S,"ListAdapter");
       tolua_function(tolua_S,"new",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_delete00);
       tolua_function(tolua_S,"getSize",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_getSize00);
       tolua_function(tolua_S,"valueOfAttr",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_valueOfAttr00);
       tolua_function(tolua_S,"addAttributeAdapter",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_addAttributeAdapter00);
       tolua_function(tolua_S,"removeAdapters",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_ListAdapter_removeAdapters00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"PositionAdapter","EmberOgre::Gui::Adapters::Atlas::PositionAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",tolua_collect_EmberOgre__Gui__Adapters__Atlas__PositionAdapter);
      #else
      tolua_cclass(tolua_S,"PositionAdapter","EmberOgre::Gui::Adapters::Atlas::PositionAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",NULL);
      #endif
      tolua_beginmodule(tolua_S,"PositionAdapter");
       tolua_function(tolua_S,"new",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PositionAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PositionAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PositionAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_PositionAdapter_delete00);
       tolua_variable(tolua_S,"EventMoveClicked",tolua_get_EmberOgre__Gui__Adapters__Atlas__PositionAdapter_EventMoveClicked,tolua_set_EmberOgre__Gui__Adapters__Atlas__PositionAdapter_EventMoveClicked);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"Position2DAdapter","EmberOgre::Gui::Adapters::Atlas::Position2DAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",tolua_collect_EmberOgre__Gui__Adapters__Atlas__Position2DAdapter);
      #else
      tolua_cclass(tolua_S,"Position2DAdapter","EmberOgre::Gui::Adapters::Atlas::Position2DAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",NULL);
      #endif
      tolua_beginmodule(tolua_S,"Position2DAdapter");
       tolua_function(tolua_S,"new",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_Position2DAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_Position2DAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_Position2DAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_Position2DAdapter_delete00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"OrientationAdapter","EmberOgre::Gui::Adapters::Atlas::OrientationAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",tolua_collect_EmberOgre__Gui__Adapters__Atlas__OrientationAdapter);
      #else
      tolua_cclass(tolua_S,"OrientationAdapter","EmberOgre::Gui::Adapters::Atlas::OrientationAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",NULL);
      #endif
      tolua_beginmodule(tolua_S,"OrientationAdapter");
       tolua_function(tolua_S,"new",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_OrientationAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_OrientationAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_OrientationAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_OrientationAdapter_delete00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EmberOgre",0);
  tolua_beginmodule(tolua_S,"EmberOgre");
   tolua_module(tolua_S,"Gui",0);
   tolua_beginmodule(tolua_S,"Gui");
    tolua_module(tolua_S,"Adapters",0);
    tolua_beginmodule(tolua_S,"Adapters");
     tolua_module(tolua_S,"Atlas",0);
     tolua_beginmodule(tolua_S,"Atlas");
      #ifdef __cplusplus
      tolua_cclass(tolua_S,"StaticAdapter","EmberOgre::Gui::Adapters::Atlas::StaticAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",tolua_collect_EmberOgre__Gui__Adapters__Atlas__StaticAdapter);
      #else
      tolua_cclass(tolua_S,"StaticAdapter","EmberOgre::Gui::Adapters::Atlas::StaticAdapter","EmberOgre::Gui::Adapters::Atlas::AdapterBase",NULL);
      #endif
      tolua_beginmodule(tolua_S,"StaticAdapter");
       tolua_function(tolua_S,"new",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StaticAdapter_new00);
       tolua_function(tolua_S,"new_local",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StaticAdapter_new00_local);
       tolua_function(tolua_S,".call",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StaticAdapter_new00_local);
       tolua_function(tolua_S,"delete",tolua_AtlasAdapters_EmberOgre_Gui_Adapters_Atlas_StaticAdapter_delete00);
      tolua_endmodule(tolua_S);
     tolua_endmodule(tolua_S);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_AtlasAdapters (lua_State* tolua_S) {
 return tolua_AtlasAdapters_open(tolua_S);
};
#endif

