/*
** Lua binding: CEGUI
** Generated automatically by tolua++-1.0.92 on Wed Mar 16 14:28:52 2011.
*/

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

#include "tolua++.h"

/* Exported function */
int tolua_CEGUI_open (lua_State* tolua_S);

#include "required.h"
#include "CEGUIPropertyHelper.h"

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

static int tolua_collect_CEGUI__Image (lua_State* tolua_S)
{
 CEGUI::Image* self = (CEGUI::Image*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__SchemeIterator (lua_State* tolua_S)
{
 CEGUI::SchemeIterator* self = (CEGUI::SchemeIterator*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__WidgetDim (lua_State* tolua_S)
{
 CEGUI::WidgetDim* self = (CEGUI::WidgetDim*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__FalagardWindowMapping (lua_State* tolua_S)
{
 CEGUI::FalagardWindowMapping* self = (CEGUI::FalagardWindowMapping*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__MouseEventArgs (lua_State* tolua_S)
{
 CEGUI::MouseEventArgs* self = (CEGUI::MouseEventArgs*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__ImageIterator (lua_State* tolua_S)
{
 CEGUI::ImageIterator* self = (CEGUI::ImageIterator*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__ImagesetIterator (lua_State* tolua_S)
{
 CEGUI::ImagesetIterator* self = (CEGUI::ImagesetIterator*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__Dimension (lua_State* tolua_S)
{
 CEGUI::Dimension* self = (CEGUI::Dimension*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__WidgetLookFeel (lua_State* tolua_S)
{
 CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__DragDropEventArgs (lua_State* tolua_S)
{
 CEGUI::DragDropEventArgs* self = (CEGUI::DragDropEventArgs*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__FileStream (lua_State* tolua_S)
{
 CEGUI::FileStream* self = (CEGUI::FileStream*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__UBox (lua_State* tolua_S)
{
 CEGUI::UBox* self = (CEGUI::UBox*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__WidgetLookManager (lua_State* tolua_S)
{
 CEGUI::WidgetLookManager* self = (CEGUI::WidgetLookManager*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__FrameComponent (lua_State* tolua_S)
{
 CEGUI::FrameComponent* self = (CEGUI::FrameComponent*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__LayerSpecification (lua_State* tolua_S)
{
 CEGUI::LayerSpecification* self = (CEGUI::LayerSpecification*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__SectionSpecification (lua_State* tolua_S)
{
 CEGUI::SectionSpecification* self = (CEGUI::SectionSpecification*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__ImagerySection (lua_State* tolua_S)
{
 CEGUI::ImagerySection* self = (CEGUI::ImagerySection*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__ColourRect (lua_State* tolua_S)
{
 CEGUI::ColourRect* self = (CEGUI::ColourRect*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__TextComponent (lua_State* tolua_S)
{
 CEGUI::TextComponent* self = (CEGUI::TextComponent*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__TreeEventArgs (lua_State* tolua_S)
{
 CEGUI::TreeEventArgs* self = (CEGUI::TreeEventArgs*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__StateImagery (lua_State* tolua_S)
{
 CEGUI::StateImagery* self = (CEGUI::StateImagery*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__EventConnection (lua_State* tolua_S)
{
 CEGUI::EventConnection* self = (CEGUI::EventConnection*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__PropertyLinkDefinition (lua_State* tolua_S)
{
 CEGUI::PropertyLinkDefinition* self = (CEGUI::PropertyLinkDefinition*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__PropertyInitialiser (lua_State* tolua_S)
{
 CEGUI::PropertyInitialiser* self = (CEGUI::PropertyInitialiser*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__Vector2 (lua_State* tolua_S)
{
 CEGUI::Vector2* self = (CEGUI::Vector2*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__String (lua_State* tolua_S)
{
 CEGUI::String* self = (CEGUI::String*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__NamedArea (lua_State* tolua_S)
{
 CEGUI::NamedArea* self = (CEGUI::NamedArea*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__PropertyDefinition (lua_State* tolua_S)
{
 CEGUI::PropertyDefinition* self = (CEGUI::PropertyDefinition*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__ComponentArea (lua_State* tolua_S)
{
 CEGUI::ComponentArea* self = (CEGUI::ComponentArea*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__EventIterator (lua_State* tolua_S)
{
 CEGUI::EventIterator* self = (CEGUI::EventIterator*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__WindowIterator (lua_State* tolua_S)
{
 CEGUI::WindowIterator* self = (CEGUI::WindowIterator*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__WindowFactoryIterator (lua_State* tolua_S)
{
 CEGUI::WindowFactoryIterator* self = (CEGUI::WindowFactoryIterator*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__Size (lua_State* tolua_S)
{
 CEGUI::Size* self = (CEGUI::Size*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__FontIterator (lua_State* tolua_S)
{
 CEGUI::FontIterator* self = (CEGUI::FontIterator*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__ActivationEventArgs (lua_State* tolua_S)
{
 CEGUI::ActivationEventArgs* self = (CEGUI::ActivationEventArgs*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__PropertyDim (lua_State* tolua_S)
{
 CEGUI::PropertyDim* self = (CEGUI::PropertyDim*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__FontDim (lua_State* tolua_S)
{
 CEGUI::FontDim* self = (CEGUI::FontDim*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__FalagardMappingIterator (lua_State* tolua_S)
{
 CEGUI::FalagardMappingIterator* self = (CEGUI::FalagardMappingIterator*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__EventArgs (lua_State* tolua_S)
{
 CEGUI::EventArgs* self = (CEGUI::EventArgs*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__UnifiedDim (lua_State* tolua_S)
{
 CEGUI::UnifiedDim* self = (CEGUI::UnifiedDim*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__UVector2 (lua_State* tolua_S)
{
 CEGUI::UVector2* self = (CEGUI::UVector2*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__ImageDim (lua_State* tolua_S)
{
 CEGUI::ImageDim* self = (CEGUI::ImageDim*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__PropertyIterator (lua_State* tolua_S)
{
 CEGUI::PropertyIterator* self = (CEGUI::PropertyIterator*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__AbsoluteDim (lua_State* tolua_S)
{
 CEGUI::AbsoluteDim* self = (CEGUI::AbsoluteDim*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__HeaderSequenceEventArgs (lua_State* tolua_S)
{
 CEGUI::HeaderSequenceEventArgs* self = (CEGUI::HeaderSequenceEventArgs*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__MCLGridRef (lua_State* tolua_S)
{
 CEGUI::MCLGridRef* self = (CEGUI::MCLGridRef*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__RenderQueueEventArgs (lua_State* tolua_S)
{
 CEGUI::RenderQueueEventArgs* self = (CEGUI::RenderQueueEventArgs*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__URect (lua_State* tolua_S)
{
 CEGUI::URect* self = (CEGUI::URect*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__Vector3 (lua_State* tolua_S)
{
 CEGUI::Vector3* self = (CEGUI::Vector3*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__ImageryComponent (lua_State* tolua_S)
{
 CEGUI::ImageryComponent* self = (CEGUI::ImageryComponent*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__WidgetComponent (lua_State* tolua_S)
{
 CEGUI::WidgetComponent* self = (CEGUI::WidgetComponent*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__KeyEventArgs (lua_State* tolua_S)
{
 CEGUI::KeyEventArgs* self = (CEGUI::KeyEventArgs*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__UDim (lua_State* tolua_S)
{
 CEGUI::UDim* self = (CEGUI::UDim*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__colour (lua_State* tolua_S)
{
 CEGUI::colour* self = (CEGUI::colour*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__MouseCursorEventArgs (lua_State* tolua_S)
{
 CEGUI::MouseCursorEventArgs* self = (CEGUI::MouseCursorEventArgs*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__WindowEventArgs (lua_State* tolua_S)
{
 CEGUI::WindowEventArgs* self = (CEGUI::WindowEventArgs*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__Rect (lua_State* tolua_S)
{
 CEGUI::Rect* self = (CEGUI::Rect*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"CEGUI::Logger");
 tolua_usertype(tolua_S,"CEGUI::Renderer");
 tolua_usertype(tolua_S,"CEGUI::FalagardComponentBase");
 tolua_usertype(tolua_S,"CEGUI::WidgetDim");
 tolua_usertype(tolua_S,"CEGUI::MouseCursorEventArgs");
 tolua_usertype(tolua_S,"CEGUI::TreeItem");
 tolua_usertype(tolua_S,"CEGUI::WindowFactory");
 tolua_usertype(tolua_S,"CEGUI::MouseCursor");
 tolua_usertype(tolua_S,"CEGUI::WidgetLookManager");
 tolua_usertype(tolua_S,"CEGUI::MultiColumnList");
 tolua_usertype(tolua_S,"CEGUI::EventConnection");
 tolua_usertype(tolua_S,"CEGUI::Property");
 tolua_usertype(tolua_S,"CEGUI::EventIterator");
 tolua_usertype(tolua_S,"CEGUI::PopupMenu");
 tolua_usertype(tolua_S,"CEGUI::PropertyHelper");
 tolua_usertype(tolua_S,"CEGUI::AnimationManager");
 tolua_usertype(tolua_S,"CEGUI::UVector2");
 tolua_usertype(tolua_S,"CEGUI::Vertex");
 tolua_usertype(tolua_S,"CEGUI::Spinner");
 tolua_usertype(tolua_S,"CEGUI::RenderQueueEventArgs");
 tolua_usertype(tolua_S,"CEGUI::Vector3");
 tolua_usertype(tolua_S,"CEGUI::ImageryComponent");
 tolua_usertype(tolua_S,"CEGUI::WidgetComponent");
 tolua_usertype(tolua_S,"CEGUI::Scheme");
 tolua_usertype(tolua_S,"CEGUI::RadioButton");
 tolua_usertype(tolua_S,"CEGUI::Tooltip");
 tolua_usertype(tolua_S,"CEGUI::ItemEntry");
 tolua_usertype(tolua_S,"CEGUI::LayoutContainer");
 tolua_usertype(tolua_S,"CEGUI::MultiLineEditbox");
 tolua_usertype(tolua_S,"CEGUI::FalagardWindowMapping");
 tolua_usertype(tolua_S,"CEGUI::WindowManager");
 tolua_usertype(tolua_S,"CEGUI::ListHeader");
 tolua_usertype(tolua_S,"CEGUI::WidgetLookFeel");
 tolua_usertype(tolua_S,"CEGUI::ColourRect");
 tolua_usertype(tolua_S,"CEGUI::StateImagery");
 tolua_usertype(tolua_S,"CEGUI::GeometryBuffer");
 tolua_usertype(tolua_S,"CEGUI::Vector2");
 tolua_usertype(tolua_S,"CEGUI::String");
 tolua_usertype(tolua_S,"CEGUI::RenderingContext");
 tolua_usertype(tolua_S,"CEGUI::VerticalLayoutContainer");
 tolua_usertype(tolua_S,"CEGUI::WindowIterator");
 tolua_usertype(tolua_S,"CEGUI::Font");
 tolua_usertype(tolua_S,"CEGUI::FontIterator");
 tolua_usertype(tolua_S,"CEGUI::Texture");
 tolua_usertype(tolua_S,"CEGUI::FalagardMappingIterator");
 tolua_usertype(tolua_S,"CEGUI::EventArgs");
 tolua_usertype(tolua_S,"CEGUI::ScrollablePane");
 tolua_usertype(tolua_S,"CEGUI::Window");
 tolua_usertype(tolua_S,"CEGUI::KeyFrame");
 tolua_usertype(tolua_S,"CEGUI::URect");
 tolua_usertype(tolua_S,"CEGUI::RenderingSurface");
 tolua_usertype(tolua_S,"CEGUI::Rect");
 tolua_usertype(tolua_S,"CEGUI::Image");
 tolua_usertype(tolua_S,"CEGUI::MenuBase");
 tolua_usertype(tolua_S,"CEGUI::SchemeIterator");
 tolua_usertype(tolua_S,"CEGUI::Scrollbar");
 tolua_usertype(tolua_S,"CEGUI::Editbox");
 tolua_usertype(tolua_S,"CEGUI::ImageIterator");
 tolua_usertype(tolua_S,"CEGUI::AnimationEventArgs");
 tolua_usertype(tolua_S,"CEGUI::Dimension");
 tolua_usertype(tolua_S,"CEGUI::DragDropEventArgs");
 tolua_usertype(tolua_S,"CEGUI::ItemListbox");
 tolua_usertype(tolua_S,"CEGUI::ComboDropList");
 tolua_usertype(tolua_S,"CEGUI::RenderEffect");
 tolua_usertype(tolua_S,"CEGUI::ButtonBase");
 tolua_usertype(tolua_S,"CEGUI::FontDim");
 tolua_usertype(tolua_S,"CEGUI::ListboxItem");
 tolua_usertype(tolua_S,"CEGUI::Imageset");
 tolua_usertype(tolua_S,"CEGUI::GroupBox");
 tolua_usertype(tolua_S,"CEGUI::UBox");
 tolua_usertype(tolua_S,"CEGUI::FileStream");
 tolua_usertype(tolua_S,"CEGUI::ImagerySection");
 tolua_usertype(tolua_S,"CEGUI::ProgressBar");
 tolua_usertype(tolua_S,"CEGUI::Tree");
 tolua_usertype(tolua_S,"CEGUI::HorizontalLayoutContainer");
 tolua_usertype(tolua_S,"CEGUI::KeyEventArgs");
 tolua_usertype(tolua_S,"CEGUI::TabControl");
 tolua_usertype(tolua_S,"CEGUI::GlobalEventSet");
 tolua_usertype(tolua_S,"CEGUI::OutStream");
 tolua_usertype(tolua_S,"CEGUI::LayerSpecification");
 tolua_usertype(tolua_S,"CEGUI::SectionSpecification");
 tolua_usertype(tolua_S,"CEGUI::TextComponent");
 tolua_usertype(tolua_S,"CEGUI::FrameComponent");
 tolua_usertype(tolua_S,"CEGUI::PropertyLinkDefinition");
 tolua_usertype(tolua_S,"CEGUI::PropertyInitialiser");
 tolua_usertype(tolua_S,"CEGUI::Affector");
 tolua_usertype(tolua_S,"CEGUI::PropertyDefinition");
 tolua_usertype(tolua_S,"CEGUI::Checkbox");
 tolua_usertype(tolua_S,"CEGUI::MouseEventArgs");
 tolua_usertype(tolua_S,"CEGUI::ImagesetIterator");
 tolua_usertype(tolua_S,"CEGUI::Animation");
 tolua_usertype(tolua_S,"CEGUI::PushButton");
 tolua_usertype(tolua_S,"CEGUI::RenderingRoot");
 tolua_usertype(tolua_S,"CEGUI::PropertyDefinitionBase");
 tolua_usertype(tolua_S,"CEGUI::FrameWindow");
 tolua_usertype(tolua_S,"CEGUI::Interpolator");
 tolua_usertype(tolua_S,"CEGUI::ComponentArea");
 tolua_usertype(tolua_S,"CEGUI::PropertyDim");
 tolua_usertype(tolua_S,"CEGUI::SequentialLayoutContainer");
 tolua_usertype(tolua_S,"CEGUI::Combobox");
 tolua_usertype(tolua_S,"CEGUI::Listbox");
 tolua_usertype(tolua_S,"CEGUI::BaseDim");
 tolua_usertype(tolua_S,"CEGUI::System");
 tolua_usertype(tolua_S,"CEGUI::WindowFactoryIterator");
 tolua_usertype(tolua_S,"CEGUI::ListboxTextItem");
 tolua_usertype(tolua_S,"CEGUI::GridLayoutContainer");
 tolua_usertype(tolua_S,"CEGUI::ItemListBase");
 tolua_usertype(tolua_S,"CEGUI::TabButton");
 tolua_usertype(tolua_S,"CEGUI::UnifiedDim");
 tolua_usertype(tolua_S,"CEGUI::NamedArea");
 tolua_usertype(tolua_S,"CEGUI::ScrolledItemListBase");
 tolua_usertype(tolua_S,"CEGUI::MenuItem");
 tolua_usertype(tolua_S,"CEGUI::WindowEventArgs");
 tolua_usertype(tolua_S,"CEGUI::Menubar");
 tolua_usertype(tolua_S,"CEGUI::colour");
 tolua_usertype(tolua_S,"CEGUI::Size");
 tolua_usertype(tolua_S,"CEGUI::FontManager");
 tolua_usertype(tolua_S,"CEGUI::ImagesetManager");
 tolua_usertype(tolua_S,"CEGUI::MCLGridRef");
 tolua_usertype(tolua_S,"CEGUI::ListHeaderSegment");
 tolua_usertype(tolua_S,"CEGUI::ImageDim");
 tolua_usertype(tolua_S,"CEGUI::SchemeManager");
 tolua_usertype(tolua_S,"CEGUI::RenderingWindow");
 tolua_usertype(tolua_S,"CEGUI::EventSet");
 tolua_usertype(tolua_S,"CEGUI::Slider");
 tolua_usertype(tolua_S,"CEGUI::PropertyIterator");
 tolua_usertype(tolua_S,"CEGUI::AbsoluteDim");
 tolua_usertype(tolua_S,"CEGUI::HeaderSequenceEventArgs");
 tolua_usertype(tolua_S,"CEGUI::Event");
 tolua_usertype(tolua_S,"CEGUI::ScrolledContainer");
 tolua_usertype(tolua_S,"CEGUI::TreeEventArgs");
 tolua_usertype(tolua_S,"CEGUI::CoordConverter");
 tolua_usertype(tolua_S,"CEGUI::DragContainer");
 tolua_usertype(tolua_S,"CEGUI::Titlebar");
 tolua_usertype(tolua_S,"CEGUI::Thumb");
 tolua_usertype(tolua_S,"CEGUI::UDim");
 tolua_usertype(tolua_S,"CEGUI::GUISheet");
 tolua_usertype(tolua_S,"CEGUI::AnimationInstance");
 tolua_usertype(tolua_S,"CEGUI::ActivationEventArgs");
 tolua_usertype(tolua_S,"CEGUI::WindowFactoryManager");
}

/* get function: d_x of class  CEGUI::Vector2 */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Vector2_x
static int tolua_get_CEGUI__Vector2_x(lua_State* tolua_S)
{
  CEGUI::Vector2* self = (CEGUI::Vector2*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_x'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_x);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_x of class  CEGUI::Vector2 */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Vector2_x
static int tolua_set_CEGUI__Vector2_x(lua_State* tolua_S)
{
  CEGUI::Vector2* self = (CEGUI::Vector2*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_x'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_x = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_y of class  CEGUI::Vector2 */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Vector2_y
static int tolua_get_CEGUI__Vector2_y(lua_State* tolua_S)
{
  CEGUI::Vector2* self = (CEGUI::Vector2*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_y'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_y);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_y of class  CEGUI::Vector2 */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Vector2_y
static int tolua_set_CEGUI__Vector2_y(lua_State* tolua_S)
{
  CEGUI::Vector2* self = (CEGUI::Vector2*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_y'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_y = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator+ of class  CEGUI::Vector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2__add00
static int tolua_CEGUI_CEGUI_Vector2__add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Vector2* self = (const CEGUI::Vector2*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* vec = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'",NULL);
#endif
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  self->operator+(*vec);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator- of class  CEGUI::Vector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2__sub00
static int tolua_CEGUI_CEGUI_Vector2__sub00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Vector2* self = (const CEGUI::Vector2*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* vec = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'",NULL);
#endif
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  self->operator-(*vec);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator* of class  CEGUI::Vector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2__mul00
static int tolua_CEGUI_CEGUI_Vector2__mul00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Vector2* self = (const CEGUI::Vector2*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* vec = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
#endif
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  self->operator*(*vec);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::Vector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2__eq00
static int tolua_CEGUI_CEGUI_Vector2__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Vector2* self = (const CEGUI::Vector2*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* vec = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*vec);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::Vector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2_new00
static int tolua_CEGUI_CEGUI_Vector2_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Vector2* tolua_ret = (CEGUI::Vector2*)  new CEGUI::Vector2();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Vector2");
 }
 }
 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  CEGUI::Vector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2_new00_local
static int tolua_CEGUI_CEGUI_Vector2_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Vector2* tolua_ret = (CEGUI::Vector2*)  new CEGUI::Vector2();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Vector2");
 }
 }
 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 of class  CEGUI::Vector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2_new01
static int tolua_CEGUI_CEGUI_Vector2_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float x = ((float)  tolua_tonumber(tolua_S,2,0));
  float y = ((float)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::Vector2* tolua_ret = (CEGUI::Vector2*)  new CEGUI::Vector2(x,y);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Vector2");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Vector2_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::Vector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2_new01_local
static int tolua_CEGUI_CEGUI_Vector2_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float x = ((float)  tolua_tonumber(tolua_S,2,0));
  float y = ((float)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::Vector2* tolua_ret = (CEGUI::Vector2*)  new CEGUI::Vector2(x,y);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Vector2");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Vector2_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_x of class  CEGUI::Vector3 */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Vector3_x
static int tolua_get_CEGUI__Vector3_x(lua_State* tolua_S)
{
  CEGUI::Vector3* self = (CEGUI::Vector3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_x'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_x);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_x of class  CEGUI::Vector3 */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Vector3_x
static int tolua_set_CEGUI__Vector3_x(lua_State* tolua_S)
{
  CEGUI::Vector3* self = (CEGUI::Vector3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_x'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_x = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_y of class  CEGUI::Vector3 */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Vector3_y
static int tolua_get_CEGUI__Vector3_y(lua_State* tolua_S)
{
  CEGUI::Vector3* self = (CEGUI::Vector3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_y'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_y);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_y of class  CEGUI::Vector3 */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Vector3_y
static int tolua_set_CEGUI__Vector3_y(lua_State* tolua_S)
{
  CEGUI::Vector3* self = (CEGUI::Vector3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_y'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_y = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_z of class  CEGUI::Vector3 */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Vector3_z
static int tolua_get_CEGUI__Vector3_z(lua_State* tolua_S)
{
  CEGUI::Vector3* self = (CEGUI::Vector3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_z'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_z);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_z of class  CEGUI::Vector3 */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Vector3_z
static int tolua_set_CEGUI__Vector3_z(lua_State* tolua_S)
{
  CEGUI::Vector3* self = (CEGUI::Vector3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_z'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_z = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::Vector3 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector3__eq00
static int tolua_CEGUI_CEGUI_Vector3__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Vector3",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Vector3* self = (const CEGUI::Vector3*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector3* vec = ((const CEGUI::Vector3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*vec);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::Vector3 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector3_new00
static int tolua_CEGUI_CEGUI_Vector3_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Vector3* tolua_ret = (CEGUI::Vector3*)  new CEGUI::Vector3();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Vector3");
 }
 }
 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  CEGUI::Vector3 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector3_new00_local
static int tolua_CEGUI_CEGUI_Vector3_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Vector3* tolua_ret = (CEGUI::Vector3*)  new CEGUI::Vector3();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Vector3");
 }
 }
 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 of class  CEGUI::Vector3 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector3_new01
static int tolua_CEGUI_CEGUI_Vector3_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector3",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float x = ((float)  tolua_tonumber(tolua_S,2,0));
  float y = ((float)  tolua_tonumber(tolua_S,3,0));
  float z = ((float)  tolua_tonumber(tolua_S,4,0));
 {
  CEGUI::Vector3* tolua_ret = (CEGUI::Vector3*)  new CEGUI::Vector3(x,y,z);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Vector3");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Vector3_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::Vector3 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector3_new01_local
static int tolua_CEGUI_CEGUI_Vector3_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector3",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float x = ((float)  tolua_tonumber(tolua_S,2,0));
  float y = ((float)  tolua_tonumber(tolua_S,3,0));
  float z = ((float)  tolua_tonumber(tolua_S,4,0));
 {
  CEGUI::Vector3* tolua_ret = (CEGUI::Vector3*)  new CEGUI::Vector3(x,y,z);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Vector3");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Vector3_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_width of class  CEGUI::Size */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Size_width
static int tolua_get_CEGUI__Size_width(lua_State* tolua_S)
{
  CEGUI::Size* self = (CEGUI::Size*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_width'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_width);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_width of class  CEGUI::Size */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Size_width
static int tolua_set_CEGUI__Size_width(lua_State* tolua_S)
{
  CEGUI::Size* self = (CEGUI::Size*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_width'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_width = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_height of class  CEGUI::Size */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Size_height
static int tolua_get_CEGUI__Size_height(lua_State* tolua_S)
{
  CEGUI::Size* self = (CEGUI::Size*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_height'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_height);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_height of class  CEGUI::Size */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Size_height
static int tolua_set_CEGUI__Size_height(lua_State* tolua_S)
{
  CEGUI::Size* self = (CEGUI::Size*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_height'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_height = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::Size */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Size__eq00
static int tolua_CEGUI_CEGUI_Size__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Size* self = (const CEGUI::Size*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* sz = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*sz);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::Size */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Size_new00
static int tolua_CEGUI_CEGUI_Size_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Size* tolua_ret = (CEGUI::Size*)  new CEGUI::Size();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Size");
 }
 }
 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  CEGUI::Size */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Size_new00_local
static int tolua_CEGUI_CEGUI_Size_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Size* tolua_ret = (CEGUI::Size*)  new CEGUI::Size();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Size");
 }
 }
 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 of class  CEGUI::Size */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Size_new01
static int tolua_CEGUI_CEGUI_Size_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Size",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float w = ((float)  tolua_tonumber(tolua_S,2,0));
  float h = ((float)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::Size* tolua_ret = (CEGUI::Size*)  new CEGUI::Size(w,h);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Size");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Size_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::Size */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Size_new01_local
static int tolua_CEGUI_CEGUI_Size_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Size",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float w = ((float)  tolua_tonumber(tolua_S,2,0));
  float h = ((float)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::Size* tolua_ret = (CEGUI::Size*)  new CEGUI::Size(w,h);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Size");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Size_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_top of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Rect_top
static int tolua_get_CEGUI__Rect_top(lua_State* tolua_S)
{
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_top'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_top);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_top of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Rect_top
static int tolua_set_CEGUI__Rect_top(lua_State* tolua_S)
{
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_top'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_top = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_bottom of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Rect_bottom
static int tolua_get_CEGUI__Rect_bottom(lua_State* tolua_S)
{
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_bottom'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_bottom);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_bottom of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Rect_bottom
static int tolua_set_CEGUI__Rect_bottom(lua_State* tolua_S)
{
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_bottom'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_bottom = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_left of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Rect_left
static int tolua_get_CEGUI__Rect_left(lua_State* tolua_S)
{
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_left'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_left);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_left of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Rect_left
static int tolua_set_CEGUI__Rect_left(lua_State* tolua_S)
{
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_left'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_left = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_right of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Rect_right
static int tolua_get_CEGUI__Rect_right(lua_State* tolua_S)
{
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_right'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_right);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_right of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Rect_right
static int tolua_set_CEGUI__Rect_right(lua_State* tolua_S)
{
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_right'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_right = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPosition of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_getPosition00
static int tolua_CEGUI_CEGUI_Rect_getPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect* self = (const CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPosition'",NULL);
#endif
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  self->getPosition();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWidth of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_getWidth00
static int tolua_CEGUI_CEGUI_Rect_getWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect* self = (const CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWidth'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getWidth();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHeight of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_getHeight00
static int tolua_CEGUI_CEGUI_Rect_getHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect* self = (const CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHeight'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getHeight();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSize of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_getSize00
static int tolua_CEGUI_CEGUI_Rect_getSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect* self = (const CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSize'",NULL);
#endif
 {
  CEGUI::Size tolua_ret = (CEGUI::Size)  self->getSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#endif
 }
 }
 }
 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: getIntersection of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_getIntersection00
static int tolua_CEGUI_CEGUI_Rect_getIntersection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect* self = (const CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Rect* rect = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIntersection'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getIntersection(*rect);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIntersection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isPointInRect of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_isPointInRect00
static int tolua_CEGUI_CEGUI_Rect_isPointInRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect* self = (const CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* p = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isPointInRect'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isPointInRect(*p);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isPointInRect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPosition of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_setPosition00
static int tolua_CEGUI_CEGUI_Rect_setPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* p = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPosition'",NULL);
#endif
 {
  self->setPosition(*p);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setWidth of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_setWidth00
static int tolua_CEGUI_CEGUI_Rect_setWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
  float w = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWidth'",NULL);
#endif
 {
  self->setWidth(w);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHeight of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_setHeight00
static int tolua_CEGUI_CEGUI_Rect_setHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
  float h = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHeight'",NULL);
#endif
 {
  self->setHeight(h);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSize of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_setSize00
static int tolua_CEGUI_CEGUI_Rect_setSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* sz = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSize'",NULL);
#endif
 {
  self->setSize(*sz);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: offset of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_offset00
static int tolua_CEGUI_CEGUI_Rect_offset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* p = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'offset'",NULL);
#endif
 {
  CEGUI::Rect& tolua_ret = (CEGUI::Rect&)  self->offset(*p);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Rect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'offset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: constrainSizeMax of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_constrainSizeMax00
static int tolua_CEGUI_CEGUI_Rect_constrainSizeMax00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* sz = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'constrainSizeMax'",NULL);
#endif
 {
  CEGUI::Rect& tolua_ret = (CEGUI::Rect&)  self->constrainSizeMax(*sz);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Rect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'constrainSizeMax'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: constrainSizeMin of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_constrainSizeMin00
static int tolua_CEGUI_CEGUI_Rect_constrainSizeMin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* sz = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'constrainSizeMin'",NULL);
#endif
 {
  CEGUI::Rect& tolua_ret = (CEGUI::Rect&)  self->constrainSizeMin(*sz);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Rect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'constrainSizeMin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: constrainSize of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_constrainSize00
static int tolua_CEGUI_CEGUI_Rect_constrainSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect* self = (CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* min = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Size* max = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'constrainSize'",NULL);
#endif
 {
  CEGUI::Rect& tolua_ret = (CEGUI::Rect&)  self->constrainSize(*min,*max);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Rect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'constrainSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect__eq00
static int tolua_CEGUI_CEGUI_Rect__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect* self = (const CEGUI::Rect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Rect* r = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*r);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_new00
static int tolua_CEGUI_CEGUI_Rect_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Rect* tolua_ret = (CEGUI::Rect*)  new CEGUI::Rect();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Rect");
 }
 }
 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  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_new00_local
static int tolua_CEGUI_CEGUI_Rect_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Rect* tolua_ret = (CEGUI::Rect*)  new CEGUI::Rect();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Rect");
 }
 }
 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 of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_new01
static int tolua_CEGUI_CEGUI_Rect_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float l = ((float)  tolua_tonumber(tolua_S,2,0));
  float t = ((float)  tolua_tonumber(tolua_S,3,0));
  float r = ((float)  tolua_tonumber(tolua_S,4,0));
  float b = ((float)  tolua_tonumber(tolua_S,5,0));
 {
  CEGUI::Rect* tolua_ret = (CEGUI::Rect*)  new CEGUI::Rect(l,t,r,b);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Rect");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Rect_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_new01_local
static int tolua_CEGUI_CEGUI_Rect_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float l = ((float)  tolua_tonumber(tolua_S,2,0));
  float t = ((float)  tolua_tonumber(tolua_S,3,0));
  float r = ((float)  tolua_tonumber(tolua_S,4,0));
  float b = ((float)  tolua_tonumber(tolua_S,5,0));
 {
  CEGUI::Rect* tolua_ret = (CEGUI::Rect*)  new CEGUI::Rect(l,t,r,b);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Rect");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Rect_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAlpha of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_getAlpha00
static int tolua_CEGUI_CEGUI_colour_getAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::colour* self = (const CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAlpha'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getAlpha();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRed of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_getRed00
static int tolua_CEGUI_CEGUI_colour_getRed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::colour* self = (const CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRed'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getRed();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getGreen of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_getGreen00
static int tolua_CEGUI_CEGUI_colour_getGreen00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::colour* self = (const CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getGreen'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getGreen();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getGreen'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBlue of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_getBlue00
static int tolua_CEGUI_CEGUI_colour_getBlue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::colour* self = (const CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBlue'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getBlue();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBlue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHue of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_getHue00
static int tolua_CEGUI_CEGUI_colour_getHue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::colour* self = (const CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHue'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getHue();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSaturation of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_getSaturation00
static int tolua_CEGUI_CEGUI_colour_getSaturation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::colour* self = (const CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSaturation'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getSaturation();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSaturation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLumination of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_getLumination00
static int tolua_CEGUI_CEGUI_colour_getLumination00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::colour* self = (const CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLumination'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getLumination();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLumination'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_set00
static int tolua_CEGUI_CEGUI_colour_set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::colour* self = (CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
  float r = ((float)  tolua_tonumber(tolua_S,2,0));
  float g = ((float)  tolua_tonumber(tolua_S,3,0));
  float b = ((float)  tolua_tonumber(tolua_S,4,0));
  float a = ((float)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(r,g,b,a);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAlpha of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_setAlpha00
static int tolua_CEGUI_CEGUI_colour_setAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::colour* self = (CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
  float a = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAlpha'",NULL);
#endif
 {
  self->setAlpha(a);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRed of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_setRed00
static int tolua_CEGUI_CEGUI_colour_setRed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::colour* self = (CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
  float r = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRed'",NULL);
#endif
 {
  self->setRed(r);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setGreen of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_setGreen00
static int tolua_CEGUI_CEGUI_colour_setGreen00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::colour* self = (CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
  float g = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setGreen'",NULL);
#endif
 {
  self->setGreen(g);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setGreen'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBlue of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_setBlue00
static int tolua_CEGUI_CEGUI_colour_setBlue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::colour* self = (CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
  float b = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBlue'",NULL);
#endif
 {
  self->setBlue(b);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBlue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRGB of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_setRGB00
static int tolua_CEGUI_CEGUI_colour_setRGB00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::colour* self = (CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
  float r = ((float)  tolua_tonumber(tolua_S,2,0));
  float g = ((float)  tolua_tonumber(tolua_S,3,0));
  float b = ((float)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRGB'",NULL);
#endif
 {
  self->setRGB(r,g,b);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRGB'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHSL of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_setHSL00
static int tolua_CEGUI_CEGUI_colour_setHSL00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::colour* self = (CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
  float hue = ((float)  tolua_tonumber(tolua_S,2,0));
  float saturation = ((float)  tolua_tonumber(tolua_S,3,0));
  float luminance = ((float)  tolua_tonumber(tolua_S,4,0));
  float alpha = ((float)  tolua_tonumber(tolua_S,5,1));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHSL'",NULL);
#endif
 {
  self->setHSL(hue,saturation,luminance,alpha);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHSL'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator+ of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour__add00
static int tolua_CEGUI_CEGUI_colour__add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::colour* self = (const CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::colour* c = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'",NULL);
#endif
 {
  CEGUI::colour tolua_ret = (CEGUI::colour)  self->operator+(*c);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::colour(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::colour");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::colour));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::colour");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator- of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour__sub00
static int tolua_CEGUI_CEGUI_colour__sub00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::colour* self = (const CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::colour* c = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'",NULL);
#endif
 {
  CEGUI::colour tolua_ret = (CEGUI::colour)  self->operator-(*c);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::colour(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::colour");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::colour));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::colour");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour__eq00
static int tolua_CEGUI_CEGUI_colour__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::colour* self = (const CEGUI::colour*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::colour* c = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*c);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_new00
static int tolua_CEGUI_CEGUI_colour_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::colour* tolua_ret = (CEGUI::colour*)  new CEGUI::colour();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::colour");
 }
 }
 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  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_new00_local
static int tolua_CEGUI_CEGUI_colour_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::colour* tolua_ret = (CEGUI::colour*)  new CEGUI::colour();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::colour");
 }
 }
 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 of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_new01
static int tolua_CEGUI_CEGUI_colour_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float r = ((float)  tolua_tonumber(tolua_S,2,0));
  float g = ((float)  tolua_tonumber(tolua_S,3,0));
  float b = ((float)  tolua_tonumber(tolua_S,4,0));
  float a = ((float)  tolua_tonumber(tolua_S,5,0));
 {
  CEGUI::colour* tolua_ret = (CEGUI::colour*)  new CEGUI::colour(r,g,b,a);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::colour");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_colour_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::colour */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_colour_new01_local
static int tolua_CEGUI_CEGUI_colour_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float r = ((float)  tolua_tonumber(tolua_S,2,0));
  float g = ((float)  tolua_tonumber(tolua_S,3,0));
  float b = ((float)  tolua_tonumber(tolua_S,4,0));
  float a = ((float)  tolua_tonumber(tolua_S,5,0));
 {
  CEGUI::colour* tolua_ret = (CEGUI::colour*)  new CEGUI::colour(r,g,b,a);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::colour");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_colour_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_top_left of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__ColourRect_top_left
static int tolua_get_CEGUI__ColourRect_top_left(lua_State* tolua_S)
{
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_top_left'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_top_left,"CEGUI::colour");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_top_left of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__ColourRect_top_left
static int tolua_set_CEGUI__ColourRect_top_left(lua_State* tolua_S)
{
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_top_left'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::colour",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_top_left = *((CEGUI::colour*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_top_right of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__ColourRect_top_right
static int tolua_get_CEGUI__ColourRect_top_right(lua_State* tolua_S)
{
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_top_right'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_top_right,"CEGUI::colour");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_top_right of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__ColourRect_top_right
static int tolua_set_CEGUI__ColourRect_top_right(lua_State* tolua_S)
{
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_top_right'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::colour",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_top_right = *((CEGUI::colour*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_bottom_left of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__ColourRect_bottom_left
static int tolua_get_CEGUI__ColourRect_bottom_left(lua_State* tolua_S)
{
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_bottom_left'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_bottom_left,"CEGUI::colour");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_bottom_left of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__ColourRect_bottom_left
static int tolua_set_CEGUI__ColourRect_bottom_left(lua_State* tolua_S)
{
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_bottom_left'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::colour",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_bottom_left = *((CEGUI::colour*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_bottom_right of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__ColourRect_bottom_right
static int tolua_get_CEGUI__ColourRect_bottom_right(lua_State* tolua_S)
{
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_bottom_right'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_bottom_right,"CEGUI::colour");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_bottom_right of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__ColourRect_bottom_right
static int tolua_set_CEGUI__ColourRect_bottom_right(lua_State* tolua_S)
{
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_bottom_right'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::colour",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_bottom_right = *((CEGUI::colour*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAlpha of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_setAlpha00
static int tolua_CEGUI_CEGUI_ColourRect_setAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
  float alpha = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAlpha'",NULL);
#endif
 {
  self->setAlpha(alpha);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTopAlpha of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_setTopAlpha00
static int tolua_CEGUI_CEGUI_ColourRect_setTopAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
  float alpha = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTopAlpha'",NULL);
#endif
 {
  self->setTopAlpha(alpha);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTopAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBottomAlpha of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_setBottomAlpha00
static int tolua_CEGUI_CEGUI_ColourRect_setBottomAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
  float alpha = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBottomAlpha'",NULL);
#endif
 {
  self->setBottomAlpha(alpha);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBottomAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setLeftAlpha of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_setLeftAlpha00
static int tolua_CEGUI_CEGUI_ColourRect_setLeftAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
  float alpha = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setLeftAlpha'",NULL);
#endif
 {
  self->setLeftAlpha(alpha);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setLeftAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRightAlpha of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_setRightAlpha00
static int tolua_CEGUI_CEGUI_ColourRect_setRightAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
  float alpha = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRightAlpha'",NULL);
#endif
 {
  self->setRightAlpha(alpha);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRightAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: modulateAlpha of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_modulateAlpha00
static int tolua_CEGUI_CEGUI_ColourRect_modulateAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
  float alpha = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'modulateAlpha'",NULL);
#endif
 {
  self->modulateAlpha(alpha);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'modulateAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setColours of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_setColours00
static int tolua_CEGUI_CEGUI_ColourRect_setColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ColourRect* self = (CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::colour* col = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setColours'",NULL);
#endif
 {
  self->setColours(*col);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getSubRectangle of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_getSubRectangle00
static int tolua_CEGUI_CEGUI_ColourRect_getSubRectangle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ColourRect* self = (const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
  float left = ((float)  tolua_tonumber(tolua_S,2,0));
  float right = ((float)  tolua_tonumber(tolua_S,3,0));
  float top = ((float)  tolua_tonumber(tolua_S,4,0));
  float bottom = ((float)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSubRectangle'",NULL);
#endif
 {
  CEGUI::ColourRect tolua_ret = (CEGUI::ColourRect)  self->getSubRectangle(left,right,top,bottom);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::ColourRect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ColourRect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::ColourRect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ColourRect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSubRectangle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColourAtPoint of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_getColourAtPoint00
static int tolua_CEGUI_CEGUI_ColourRect_getColourAtPoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ColourRect* self = (const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,1,0);
  float x = ((float)  tolua_tonumber(tolua_S,2,0));
  float y = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColourAtPoint'",NULL);
#endif
 {
  CEGUI::colour tolua_ret = (CEGUI::colour)  self->getColourAtPoint(x,y);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::colour(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::colour");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::colour));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::colour");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColourAtPoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_new00
static int tolua_CEGUI_CEGUI_ColourRect_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::ColourRect* tolua_ret = (CEGUI::ColourRect*)  new CEGUI::ColourRect();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ColourRect");
 }
 }
 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  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_new00_local
static int tolua_CEGUI_CEGUI_ColourRect_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::ColourRect* tolua_ret = (CEGUI::ColourRect*)  new CEGUI::ColourRect();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::ColourRect");
 }
 }
 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 of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_new01
static int tolua_CEGUI_CEGUI_ColourRect_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::colour* col = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::ColourRect* tolua_ret = (CEGUI::ColourRect*)  new CEGUI::ColourRect(*col);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ColourRect");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ColourRect_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_new01_local
static int tolua_CEGUI_CEGUI_ColourRect_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::colour* col = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::ColourRect* tolua_ret = (CEGUI::ColourRect*)  new CEGUI::ColourRect(*col);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::ColourRect");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ColourRect_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_new02
static int tolua_CEGUI_CEGUI_ColourRect_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::colour* top_left = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::colour* top_right = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::colour* bottom_left = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::colour* bottom_right = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,5,0));
 {
  CEGUI::ColourRect* tolua_ret = (CEGUI::ColourRect*)  new CEGUI::ColourRect(*top_left,*top_right,*bottom_left,*bottom_right);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ColourRect");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ColourRect_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::ColourRect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ColourRect_new02_local
static int tolua_CEGUI_CEGUI_ColourRect_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::colour* top_left = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::colour* top_right = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::colour* bottom_left = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::colour* bottom_right = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,5,0));
 {
  CEGUI::ColourRect* tolua_ret = (CEGUI::ColourRect*)  new CEGUI::ColourRect(*top_left,*top_right,*bottom_left,*bottom_right);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::ColourRect");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ColourRect_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* get function: npos of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__String_unsigned_npos
static int tolua_get_CEGUI__String_unsigned_npos(lua_State* tolua_S)
{
 tolua_pushnumber(tolua_S,(lua_Number)CEGUI::String::npos);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: size of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_size00
static int tolua_CEGUI_CEGUI_String_size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::String* self = (const CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->size();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: length of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_length00
static int tolua_CEGUI_CEGUI_String_length00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::String* self = (const CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->length();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'length'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: capacity of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_capacity00
static int tolua_CEGUI_CEGUI_String_capacity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::String* self = (const CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'capacity'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->capacity();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'capacity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator&[] of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String__seti00
static int tolua_CEGUI_CEGUI_String__seti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::String* self = (CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  unsigned long i = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  unsigned long tolua_value = ((unsigned long)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator&[]'",NULL);
#endif
 self->operator[](i) =  tolua_value;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.seti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator[] of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String__geti00
static int tolua_CEGUI_CEGUI_String__geti00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::String* self = (CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  unsigned long i = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator[]'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->operator[](i);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.geti'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: at of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_at00
static int tolua_CEGUI_CEGUI_String_at00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::String* self = (CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  unsigned long i = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'at'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->at(i);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'at'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: c_str of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_c_str00
static int tolua_CEGUI_CEGUI_String_c_str00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::String* self = (const CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'c_str'",NULL);
#endif
 {
  string tolua_ret = (string)  self->c_str();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'c_str'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reserve of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_reserve00
static int tolua_CEGUI_CEGUI_String_reserve00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::String* self = (CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  unsigned long num = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reserve'",NULL);
#endif
 {
  self->reserve(num);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reserve'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resize of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_resize00
static int tolua_CEGUI_CEGUI_String_resize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::String* self = (CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  unsigned long num = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resize'",NULL);
#endif
 {
  self->resize(num);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resize of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_resize01
static int tolua_CEGUI_CEGUI_String_resize01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::String* self = (CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  unsigned long num = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  unsigned long codepoint = ((unsigned long)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resize'",NULL);
#endif
 {
  self->resize(num,codepoint);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_String_resize00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_clear00
static int tolua_CEGUI_CEGUI_String_clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::String* self = (CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'",NULL);
#endif
 {
  self->clear();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: erase of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_erase00
static int tolua_CEGUI_CEGUI_String_erase00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::String* self = (CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'erase'",NULL);
#endif
 {
  CEGUI::String& tolua_ret = (CEGUI::String&)  self->erase();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::String");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'erase'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: erase of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_erase01
static int tolua_CEGUI_CEGUI_String_erase01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::String* self = (CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  unsigned long idx = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  unsigned long len = ((unsigned long)  tolua_tonumber(tolua_S,3,1));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'erase'",NULL);
#endif
 {
  CEGUI::String& tolua_ret = (CEGUI::String&)  self->erase(idx,len);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::String");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_String_erase00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: replace of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_replace00
static int tolua_CEGUI_CEGUI_String_replace00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::String* self = (CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  unsigned long begin = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  unsigned long len = ((unsigned long)  tolua_tonumber(tolua_S,3,0));
  const CEGUI::String* s = ((const CEGUI::String*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'replace'",NULL);
#endif
 {
  CEGUI::String& tolua_ret = (CEGUI::String&)  self->replace(begin,len,*s);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::String");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'replace'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: swap of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_swap00
static int tolua_CEGUI_CEGUI_String_swap00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::String* self = (CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::String* s = ((CEGUI::String*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'swap'",NULL);
#endif
 {
  self->swap(*s);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'swap'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insert of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_insert00
static int tolua_CEGUI_CEGUI_String_insert00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::String* self = (CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  unsigned long pos = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  const CEGUI::String* s = ((const CEGUI::String*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insert'",NULL);
#endif
 {
  CEGUI::String& tolua_ret = (CEGUI::String&)  self->insert(pos,*s);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::String");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'insert'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: find of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_find00
static int tolua_CEGUI_CEGUI_String_find00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::String* self = (const CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  unsigned long codepoint = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  unsigned long idx = ((unsigned long)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'find'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->find(codepoint,idx);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'find'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: rfind of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_rfind00
static int tolua_CEGUI_CEGUI_String_rfind00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::String* self = (const CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  unsigned long codepoint = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  unsigned long idx = ((unsigned long)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rfind'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->rfind(codepoint,idx);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'rfind'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: find of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_find01
static int tolua_CEGUI_CEGUI_String_find01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::String* self = (const CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::String* sub = ((const CEGUI::String*)  tolua_tousertype(tolua_S,2,0));
  unsigned long idx = ((unsigned long)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'find'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->find(*sub,idx);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_String_find00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: rfind of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_rfind01
static int tolua_CEGUI_CEGUI_String_rfind01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::String* self = (const CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::String* sub = ((const CEGUI::String*)  tolua_tousertype(tolua_S,2,0));
  unsigned long idx = ((unsigned long)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rfind'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->rfind(*sub,idx);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_String_rfind00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: substr of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_substr00
static int tolua_CEGUI_CEGUI_String_substr00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::String* self = (const CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  unsigned long idx = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  unsigned long len = ((unsigned long)  tolua_tonumber(tolua_S,3,-1));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'substr'",NULL);
#endif
 {
  CEGUI::String tolua_ret = (CEGUI::String)  self->substr(idx,len);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::String(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::String");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::String));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::String");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'substr'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: push_back of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_push_back00
static int tolua_CEGUI_CEGUI_String_push_back00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::String* self = (CEGUI::String*)  tolua_tousertype(tolua_S,1,0);
  unsigned long codepoint = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'push_back'",NULL);
#endif
 {
  self->push_back(codepoint);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'push_back'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_new00
static int tolua_CEGUI_CEGUI_String_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::String* tolua_ret = (CEGUI::String*)  new CEGUI::String();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::String");
 }
 }
 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  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_new00_local
static int tolua_CEGUI_CEGUI_String_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::String* tolua_ret = (CEGUI::String*)  new CEGUI::String();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::String");
 }
 }
 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 of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_new01
static int tolua_CEGUI_CEGUI_String_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  unsigned long num = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  unsigned long codepoint = ((unsigned long)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::String* tolua_ret = (CEGUI::String*)  new CEGUI::String(num,codepoint);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::String");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_String_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_new01_local
static int tolua_CEGUI_CEGUI_String_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  unsigned long num = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  unsigned long codepoint = ((unsigned long)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::String* tolua_ret = (CEGUI::String*)  new CEGUI::String(num,codepoint);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::String");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_String_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_new02
static int tolua_CEGUI_CEGUI_String_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  utf8string s = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::String* tolua_ret = (CEGUI::String*)  new CEGUI::String(s);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::String");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_String_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_new02_local
static int tolua_CEGUI_CEGUI_String_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  utf8string s = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::String* tolua_ret = (CEGUI::String*)  new CEGUI::String(s);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::String");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_String_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_new03
static int tolua_CEGUI_CEGUI_String_new03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::String* s = ((const CEGUI::String*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::String* tolua_ret = (CEGUI::String*)  new CEGUI::String(*s);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::String");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_String_new02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::String */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_String_new03_local
static int tolua_CEGUI_CEGUI_String_new03_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::String",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::String",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::String* s = ((const CEGUI::String*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::String* tolua_ret = (CEGUI::String*)  new CEGUI::String(*s);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::String");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_String_new02_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_scale of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__UDim_scale
static int tolua_get_CEGUI__UDim_scale(lua_State* tolua_S)
{
  CEGUI::UDim* self = (CEGUI::UDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_scale'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_scale);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_scale of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__UDim_scale
static int tolua_set_CEGUI__UDim_scale(lua_State* tolua_S)
{
  CEGUI::UDim* self = (CEGUI::UDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_scale'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_scale = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_offset of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__UDim_offset
static int tolua_get_CEGUI__UDim_offset(lua_State* tolua_S)
{
  CEGUI::UDim* self = (CEGUI::UDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_offset'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_offset);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_offset of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__UDim_offset
static int tolua_set_CEGUI__UDim_offset(lua_State* tolua_S)
{
  CEGUI::UDim* self = (CEGUI::UDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_offset'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_offset = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: asAbsolute of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UDim_asAbsolute00
static int tolua_CEGUI_CEGUI_UDim_asAbsolute00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UDim* self = (const CEGUI::UDim*)  tolua_tousertype(tolua_S,1,0);
  float base = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asAbsolute'",NULL);
#endif
 {
  float tolua_ret = (float)  self->asAbsolute(base);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'asAbsolute'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: asRelative of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UDim_asRelative00
static int tolua_CEGUI_CEGUI_UDim_asRelative00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UDim* self = (const CEGUI::UDim*)  tolua_tousertype(tolua_S,1,0);
  float base = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asRelative'",NULL);
#endif
 {
  float tolua_ret = (float)  self->asRelative(base);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'asRelative'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator+ of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UDim__add00
static int tolua_CEGUI_CEGUI_UDim__add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UDim* self = (const CEGUI::UDim*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* other = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'",NULL);
#endif
 {
  CEGUI::UDim tolua_ret = (CEGUI::UDim)  self->operator+(*other);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UDim(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UDim));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator- of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UDim__sub00
static int tolua_CEGUI_CEGUI_UDim__sub00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UDim* self = (const CEGUI::UDim*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* other = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'",NULL);
#endif
 {
  CEGUI::UDim tolua_ret = (CEGUI::UDim)  self->operator-(*other);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UDim(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UDim));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator/ of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UDim__div00
static int tolua_CEGUI_CEGUI_UDim__div00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UDim* self = (const CEGUI::UDim*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* other = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator/'",NULL);
#endif
 {
  CEGUI::UDim tolua_ret = (CEGUI::UDim)  self->operator/(*other);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UDim(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UDim));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.div'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator* of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UDim__mul00
static int tolua_CEGUI_CEGUI_UDim__mul00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UDim* self = (const CEGUI::UDim*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* other = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
#endif
 {
  CEGUI::UDim tolua_ret = (CEGUI::UDim)  self->operator*(*other);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UDim(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UDim));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UDim__eq00
static int tolua_CEGUI_CEGUI_UDim__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UDim* self = (const CEGUI::UDim*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* other = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*other);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UDim_new00
static int tolua_CEGUI_CEGUI_UDim_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::UDim* tolua_ret = (CEGUI::UDim*)  new CEGUI::UDim();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::UDim");
 }
 }
 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  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UDim_new00_local
static int tolua_CEGUI_CEGUI_UDim_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::UDim* tolua_ret = (CEGUI::UDim*)  new CEGUI::UDim();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::UDim");
 }
 }
 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 of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UDim_new01
static int tolua_CEGUI_CEGUI_UDim_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float scale = ((float)  tolua_tonumber(tolua_S,2,0));
  float offset = ((float)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::UDim* tolua_ret = (CEGUI::UDim*)  new CEGUI::UDim(scale,offset);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::UDim");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_UDim_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::UDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UDim_new01_local
static int tolua_CEGUI_CEGUI_UDim_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  float scale = ((float)  tolua_tonumber(tolua_S,2,0));
  float offset = ((float)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::UDim* tolua_ret = (CEGUI::UDim*)  new CEGUI::UDim(scale,offset);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::UDim");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_UDim_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_x of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__UVector2_x
static int tolua_get_CEGUI__UVector2_x(lua_State* tolua_S)
{
  CEGUI::UVector2* self = (CEGUI::UVector2*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_x'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_x,"CEGUI::UDim");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_x of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__UVector2_x
static int tolua_set_CEGUI__UVector2_x(lua_State* tolua_S)
{
  CEGUI::UVector2* self = (CEGUI::UVector2*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_x'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::UDim",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_x = *((CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_y of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__UVector2_y
static int tolua_get_CEGUI__UVector2_y(lua_State* tolua_S)
{
  CEGUI::UVector2* self = (CEGUI::UVector2*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_y'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_y,"CEGUI::UDim");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_y of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__UVector2_y
static int tolua_set_CEGUI__UVector2_y(lua_State* tolua_S)
{
  CEGUI::UVector2* self = (CEGUI::UVector2*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_y'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::UDim",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_y = *((CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: asAbsolute of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UVector2_asAbsolute00
static int tolua_CEGUI_CEGUI_UVector2_asAbsolute00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UVector2* self = (const CEGUI::UVector2*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* base = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asAbsolute'",NULL);
#endif
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  self->asAbsolute(*base);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'asAbsolute'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: asRelative of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UVector2_asRelative00
static int tolua_CEGUI_CEGUI_UVector2_asRelative00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UVector2* self = (const CEGUI::UVector2*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* base = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asRelative'",NULL);
#endif
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  self->asRelative(*base);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'asRelative'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator+ of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UVector2__add00
static int tolua_CEGUI_CEGUI_UVector2__add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UVector2* self = (const CEGUI::UVector2*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* other = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'",NULL);
#endif
 {
  CEGUI::UVector2 tolua_ret = (CEGUI::UVector2)  self->operator+(*other);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UVector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UVector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator- of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UVector2__sub00
static int tolua_CEGUI_CEGUI_UVector2__sub00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UVector2* self = (const CEGUI::UVector2*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* other = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'",NULL);
#endif
 {
  CEGUI::UVector2 tolua_ret = (CEGUI::UVector2)  self->operator-(*other);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UVector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UVector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator/ of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UVector2__div00
static int tolua_CEGUI_CEGUI_UVector2__div00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UVector2* self = (const CEGUI::UVector2*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* other = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator/'",NULL);
#endif
 {
  CEGUI::UVector2 tolua_ret = (CEGUI::UVector2)  self->operator/(*other);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UVector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UVector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.div'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator* of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UVector2__mul00
static int tolua_CEGUI_CEGUI_UVector2__mul00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UVector2* self = (const CEGUI::UVector2*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* other = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
#endif
 {
  CEGUI::UVector2 tolua_ret = (CEGUI::UVector2)  self->operator*(*other);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UVector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UVector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UVector2__eq00
static int tolua_CEGUI_CEGUI_UVector2__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UVector2* self = (const CEGUI::UVector2*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* other = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*other);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UVector2_new00
static int tolua_CEGUI_CEGUI_UVector2_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::UVector2* tolua_ret = (CEGUI::UVector2*)  new CEGUI::UVector2();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::UVector2");
 }
 }
 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  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UVector2_new00_local
static int tolua_CEGUI_CEGUI_UVector2_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::UVector2* tolua_ret = (CEGUI::UVector2*)  new CEGUI::UVector2();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::UVector2");
 }
 }
 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 of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UVector2_new01
static int tolua_CEGUI_CEGUI_UVector2_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::UDim* scale = ((CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::UDim* offset = ((CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::UVector2* tolua_ret = (CEGUI::UVector2*)  new CEGUI::UVector2(*scale,*offset);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::UVector2");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_UVector2_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::UVector2 */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UVector2_new01_local
static int tolua_CEGUI_CEGUI_UVector2_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::UDim* scale = ((CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::UDim* offset = ((CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::UVector2* tolua_ret = (CEGUI::UVector2*)  new CEGUI::UVector2(*scale,*offset);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::UVector2");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_UVector2_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_min of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__URect_min
static int tolua_get_CEGUI__URect_min(lua_State* tolua_S)
{
  CEGUI::URect* self = (CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_min'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_min,"CEGUI::UVector2");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_min of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__URect_min
static int tolua_set_CEGUI__URect_min(lua_State* tolua_S)
{
  CEGUI::URect* self = (CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_min'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::UVector2",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_min = *((CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_max of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__URect_max
static int tolua_get_CEGUI__URect_max(lua_State* tolua_S)
{
  CEGUI::URect* self = (CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_max'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_max,"CEGUI::UVector2");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_max of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__URect_max
static int tolua_set_CEGUI__URect_max(lua_State* tolua_S)
{
  CEGUI::URect* self = (CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_max'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::UVector2",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_max = *((CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: asAbsolute of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_asAbsolute00
static int tolua_CEGUI_CEGUI_URect_asAbsolute00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::URect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::URect* self = (const CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* base = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asAbsolute'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->asAbsolute(*base);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'asAbsolute'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: asRelative of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_asRelative00
static int tolua_CEGUI_CEGUI_URect_asRelative00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::URect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::URect* self = (const CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* base = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'asRelative'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->asRelative(*base);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'asRelative'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPosition of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_getPosition00
static int tolua_CEGUI_CEGUI_URect_getPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::URect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::URect* self = (const CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPosition'",NULL);
#endif
 {
  const CEGUI::UVector2& tolua_ret = (const CEGUI::UVector2&)  self->getPosition();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::UVector2");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSize of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_getSize00
static int tolua_CEGUI_CEGUI_URect_getSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::URect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::URect* self = (const CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSize'",NULL);
#endif
 {
  CEGUI::UVector2 tolua_ret = (CEGUI::UVector2)  self->getSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UVector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UVector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#endif
 }
 }
 }
 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: getWidth of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_getWidth00
static int tolua_CEGUI_CEGUI_URect_getWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::URect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::URect* self = (const CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWidth'",NULL);
#endif
 {
  CEGUI::UDim tolua_ret = (CEGUI::UDim)  self->getWidth();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UDim(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UDim));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHeight of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_getHeight00
static int tolua_CEGUI_CEGUI_URect_getHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::URect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::URect* self = (const CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHeight'",NULL);
#endif
 {
  CEGUI::UDim tolua_ret = (CEGUI::UDim)  self->getHeight();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UDim(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UDim));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPosition of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_setPosition00
static int tolua_CEGUI_CEGUI_URect_setPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::URect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::URect* self = (CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* pos = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPosition'",NULL);
#endif
 {
  self->setPosition(*pos);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSize of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_setSize00
static int tolua_CEGUI_CEGUI_URect_setSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::URect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::URect* self = (CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* sz = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSize'",NULL);
#endif
 {
  self->setSize(*sz);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setWidth of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_setWidth00
static int tolua_CEGUI_CEGUI_URect_setWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::URect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::URect* self = (CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* w = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWidth'",NULL);
#endif
 {
  self->setWidth(*w);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHeight of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_setHeight00
static int tolua_CEGUI_CEGUI_URect_setHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::URect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::URect* self = (CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* h = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHeight'",NULL);
#endif
 {
  self->setHeight(*h);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: offset of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_offset00
static int tolua_CEGUI_CEGUI_URect_offset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::URect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::URect* self = (CEGUI::URect*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* sz = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'offset'",NULL);
#endif
 {
  self->offset(*sz);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'offset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_new00
static int tolua_CEGUI_CEGUI_URect_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::URect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::URect* tolua_ret = (CEGUI::URect*)  new CEGUI::URect();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::URect");
 }
 }
 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  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_new00_local
static int tolua_CEGUI_CEGUI_URect_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::URect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::URect* tolua_ret = (CEGUI::URect*)  new CEGUI::URect();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::URect");
 }
 }
 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 of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_new01
static int tolua_CEGUI_CEGUI_URect_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::URect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UVector2* min = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UVector2* max = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::URect* tolua_ret = (CEGUI::URect*)  new CEGUI::URect(*min,*max);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::URect");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_URect_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_new01_local
static int tolua_CEGUI_CEGUI_URect_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::URect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UVector2* min = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UVector2* max = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::URect* tolua_ret = (CEGUI::URect*)  new CEGUI::URect(*min,*max);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::URect");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_URect_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_new02
static int tolua_CEGUI_CEGUI_URect_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::URect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UDim* left = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UDim* top = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::UDim* right = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::UDim* bottom = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,5,0));
 {
  CEGUI::URect* tolua_ret = (CEGUI::URect*)  new CEGUI::URect(*left,*top,*right,*bottom);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::URect");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_URect_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::URect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_URect_new02_local
static int tolua_CEGUI_CEGUI_URect_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::URect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UDim* left = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UDim* top = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::UDim* right = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::UDim* bottom = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,5,0));
 {
  CEGUI::URect* tolua_ret = (CEGUI::URect*)  new CEGUI::URect(*left,*top,*right,*bottom);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::URect");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_URect_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UBox_new00
static int tolua_CEGUI_CEGUI_UBox_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UBox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::UBox* tolua_ret = (CEGUI::UBox*)  new CEGUI::UBox();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::UBox");
 }
 }
 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  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UBox_new00_local
static int tolua_CEGUI_CEGUI_UBox_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UBox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::UBox* tolua_ret = (CEGUI::UBox*)  new CEGUI::UBox();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::UBox");
 }
 }
 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 of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UBox_new01
static int tolua_CEGUI_CEGUI_UBox_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UBox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UDim* margin = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::UBox* tolua_ret = (CEGUI::UBox*)  new CEGUI::UBox(*margin);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::UBox");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_UBox_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UBox_new01_local
static int tolua_CEGUI_CEGUI_UBox_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UBox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UDim* margin = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::UBox* tolua_ret = (CEGUI::UBox*)  new CEGUI::UBox(*margin);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::UBox");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_UBox_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UBox_new02
static int tolua_CEGUI_CEGUI_UBox_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UBox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UDim* top = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UDim* left = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::UDim* bottom = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::UDim* right = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,5,0));
 {
  CEGUI::UBox* tolua_ret = (CEGUI::UBox*)  new CEGUI::UBox(*top,*left,*bottom,*right);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::UBox");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_UBox_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UBox_new02_local
static int tolua_CEGUI_CEGUI_UBox_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UBox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UDim* top = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UDim* left = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::UDim* bottom = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::UDim* right = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,5,0));
 {
  CEGUI::UBox* tolua_ret = (CEGUI::UBox*)  new CEGUI::UBox(*top,*left,*bottom,*right);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::UBox");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_UBox_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UBox_new03
static int tolua_CEGUI_CEGUI_UBox_new03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UBox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UBox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UBox* b = ((const CEGUI::UBox*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::UBox* tolua_ret = (CEGUI::UBox*)  new CEGUI::UBox(*b);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::UBox");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_UBox_new02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UBox_new03_local
static int tolua_CEGUI_CEGUI_UBox_new03_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UBox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UBox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UBox* b = ((const CEGUI::UBox*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::UBox* tolua_ret = (CEGUI::UBox*)  new CEGUI::UBox(*b);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::UBox");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_UBox_new02_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UBox__eq00
static int tolua_CEGUI_CEGUI_UBox__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UBox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UBox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UBox* self = (const CEGUI::UBox*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UBox* rhs = ((const CEGUI::UBox*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*rhs);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_top of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__UBox_top
static int tolua_get_CEGUI__UBox_top(lua_State* tolua_S)
{
  CEGUI::UBox* self = (CEGUI::UBox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_top'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_top,"CEGUI::UDim");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_top of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__UBox_top
static int tolua_set_CEGUI__UBox_top(lua_State* tolua_S)
{
  CEGUI::UBox* self = (CEGUI::UBox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_top'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::UDim",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_top = *((CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_left of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__UBox_left
static int tolua_get_CEGUI__UBox_left(lua_State* tolua_S)
{
  CEGUI::UBox* self = (CEGUI::UBox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_left'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_left,"CEGUI::UDim");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_left of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__UBox_left
static int tolua_set_CEGUI__UBox_left(lua_State* tolua_S)
{
  CEGUI::UBox* self = (CEGUI::UBox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_left'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::UDim",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_left = *((CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_bottom of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__UBox_bottom
static int tolua_get_CEGUI__UBox_bottom(lua_State* tolua_S)
{
  CEGUI::UBox* self = (CEGUI::UBox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_bottom'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_bottom,"CEGUI::UDim");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_bottom of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__UBox_bottom
static int tolua_set_CEGUI__UBox_bottom(lua_State* tolua_S)
{
  CEGUI::UBox* self = (CEGUI::UBox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_bottom'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::UDim",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_bottom = *((CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_right of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__UBox_right
static int tolua_get_CEGUI__UBox_right(lua_State* tolua_S)
{
  CEGUI::UBox* self = (CEGUI::UBox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_right'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_right,"CEGUI::UDim");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_right of class  CEGUI::UBox */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__UBox_right
static int tolua_set_CEGUI__UBox_right(lua_State* tolua_S)
{
  CEGUI::UBox* self = (CEGUI::UBox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_right'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::UDim",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_right = *((CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  CEGUI::Logger */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Logger_getSingleton00
static int tolua_CEGUI_CEGUI_Logger_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Logger",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Logger& tolua_ret = (CEGUI::Logger&)  CEGUI::Logger::getSingleton();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Logger");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setLoggingLevel of class  CEGUI::Logger */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Logger_setLoggingLevel00
static int tolua_CEGUI_CEGUI_Logger_setLoggingLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Logger",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Logger* self = (CEGUI::Logger*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::LoggingLevel level = ((CEGUI::LoggingLevel) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setLoggingLevel'",NULL);
#endif
 {
  self->setLoggingLevel(level);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setLoggingLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLoggingLevel of class  CEGUI::Logger */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Logger_getLoggingLevel00
static int tolua_CEGUI_CEGUI_Logger_getLoggingLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Logger",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Logger* self = (const CEGUI::Logger*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLoggingLevel'",NULL);
#endif
 {
  CEGUI::LoggingLevel tolua_ret = (CEGUI::LoggingLevel)  self->getLoggingLevel();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLoggingLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: logEvent of class  CEGUI::Logger */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Logger_logEvent00
static int tolua_CEGUI_CEGUI_Logger_logEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Logger",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Logger* self = (CEGUI::Logger*)  tolua_tousertype(tolua_S,1,0);
  utf8string message = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::LoggingLevel level = ((CEGUI::LoggingLevel) (int)  tolua_tonumber(tolua_S,3,CEGUI::Standard));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'logEvent'",NULL);
#endif
 {
  self->logEvent(message,level);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'logEvent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setProperty of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_setProperty00
static int tolua_CEGUI_CEGUI_Font_setProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Font",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Font* self = (CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string value = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setProperty'",NULL);
#endif
 {
  self->setProperty(name,value);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setProperty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getProperty of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_getProperty00
static int tolua_CEGUI_CEGUI_Font_getProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Font",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Font* self = (const CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getProperty'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getProperty(name);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getProperty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPropertyDefault of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_getPropertyDefault00
static int tolua_CEGUI_CEGUI_Font_getPropertyDefault00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Font",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Font* self = (const CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPropertyDefault'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getPropertyDefault(name);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPropertyDefault'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPropertyHelp of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_getPropertyHelp00
static int tolua_CEGUI_CEGUI_Font_getPropertyHelp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Font",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Font* self = (const CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPropertyHelp'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getPropertyHelp(name);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPropertyHelp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isPropertyPresent of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_isPropertyPresent00
static int tolua_CEGUI_CEGUI_Font_isPropertyPresent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Font",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Font* self = (const CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isPropertyPresent'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isPropertyPresent(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isPropertyPresent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isPropertyDefault of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_isPropertyDefault00
static int tolua_CEGUI_CEGUI_Font_isPropertyDefault00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Font",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Font* self = (const CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isPropertyDefault'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isPropertyDefault(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isPropertyDefault'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ceguiLua_getPropertyIterator of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_getPropertyIterator00
static int tolua_CEGUI_CEGUI_Font_getPropertyIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Font",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Font* self = (const CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ceguiLua_getPropertyIterator'",NULL);
#endif
 {
  CEGUI::PropertyIterator tolua_ret = (CEGUI::PropertyIterator)  ceguiLua_getPropertyIterator(self);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::PropertyIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::PropertyIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::PropertyIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::PropertyIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPropertyIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDefaultResourceGroup of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_setDefaultResourceGroup00
static int tolua_CEGUI_CEGUI_Font_setDefaultResourceGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Font",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string resourceGroup = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::Font::setDefaultResourceGroup(resourceGroup);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDefaultResourceGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultResourceGroup of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_getDefaultResourceGroup00
static int tolua_CEGUI_CEGUI_Font_getDefaultResourceGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Font",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  string tolua_ret = (string)  CEGUI::Font::getDefaultResourceGroup();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultResourceGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isCodepointAvailable of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_isCodepointAvailable00
static int tolua_CEGUI_CEGUI_Font_isCodepointAvailable00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Font",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Font* self = (const CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  unsigned long cp = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isCodepointAvailable'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isCodepointAvailable(cp);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isCodepointAvailable'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNativeResolution of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_setNativeResolution00
static int tolua_CEGUI_CEGUI_Font_setNativeResolution00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Font",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Font* self = (CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* sz = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNativeResolution'",NULL);
#endif
 {
  self->setNativeResolution(*sz);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNativeResolution'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: notifyDisplaySizeChanged of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_notifyDisplaySizeChanged00
static int tolua_CEGUI_CEGUI_Font_notifyDisplaySizeChanged00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Font",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Font* self = (CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* sz = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'notifyDisplaySizeChanged'",NULL);
#endif
 {
  self->notifyDisplaySizeChanged(*sz);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'notifyDisplaySizeChanged'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTextExtent of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_getTextExtent00
static int tolua_CEGUI_CEGUI_Font_getTextExtent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Font",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Font* self = (CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  float xscale = ((float)  tolua_tonumber(tolua_S,3,1));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTextExtent'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getTextExtent(text,xscale);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTextExtent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLineSpacing of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_getLineSpacing00
static int tolua_CEGUI_CEGUI_Font_getLineSpacing00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Font",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Font* self = (const CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  float yscale = ((float)  tolua_tonumber(tolua_S,2,1));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLineSpacing'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getLineSpacing(yscale);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLineSpacing'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFontHeight of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_getFontHeight00
static int tolua_CEGUI_CEGUI_Font_getFontHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Font",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Font* self = (const CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  float yscale = ((float)  tolua_tonumber(tolua_S,2,1));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFontHeight'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getFontHeight(yscale);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFontHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCharAtPixel of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_getCharAtPixel00
static int tolua_CEGUI_CEGUI_Font_getCharAtPixel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Font",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Font* self = (CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  unsigned long start_char = ((unsigned long)  tolua_tonumber(tolua_S,3,0));
  float pixel = ((float)  tolua_tonumber(tolua_S,4,0));
  float xscale = ((float)  tolua_tonumber(tolua_S,5,1));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCharAtPixel'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getCharAtPixel(text,start_char,pixel,xscale);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCharAtPixel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCharAtPixel of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_getCharAtPixel01
static int tolua_CEGUI_CEGUI_Font_getCharAtPixel01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Font",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Font* self = (CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  float pixel = ((float)  tolua_tonumber(tolua_S,3,0));
  float xscale = ((float)  tolua_tonumber(tolua_S,4,1));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCharAtPixel'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getCharAtPixel(text,pixel,xscale);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Font_getCharAtPixel00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_getSingleton00
static int tolua_CEGUI_CEGUI_FontManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::FontManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::FontManager& tolua_ret = (CEGUI::FontManager&)  CEGUI::FontManager::getSingleton();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::FontManager");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_create00
static int tolua_CEGUI_CEGUI_FontManager_create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontManager* self = (CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string xml_filename = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string resourcegroup = ((utf8string)  tolua_toutf8string(tolua_S,3,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::Font& tolua_ret = (CEGUI::Font&)  self->create(xml_filename,resourcegroup);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Font");
 }
catch(CEGUI::AlreadyExistsException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::AlreadyExistsException' was thrown by function 'create'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createFreeTypeFont of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_createFreeTypeFont00
static int tolua_CEGUI_CEGUI_FontManager_createFreeTypeFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,4,0,&tolua_err) ||
 !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,6,1,&tolua_err) ||
 !tolua_isboolean(tolua_S,7,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,8,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,9,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,10,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,11,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontManager* self = (CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string font_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  float point_size = ((float)  tolua_tonumber(tolua_S,3,0));
  bool anti_aliased = ((bool)  tolua_toboolean(tolua_S,4,0));
  string font_filename = ((string)  tolua_tocppstring(tolua_S,5,0));
  utf8string resource_group = ((utf8string)  tolua_toutf8string(tolua_S,6,""));
  bool auto_scaled = ((bool)  tolua_toboolean(tolua_S,7,false));
  float native_horz_res = ((float)  tolua_tonumber(tolua_S,8,640.0f));
  float native_vert_res = ((float)  tolua_tonumber(tolua_S,9,480.0f));
  CEGUI::XMLResourceExistsAction action = ((CEGUI::XMLResourceExistsAction) (int)  tolua_tonumber(tolua_S,10,CEGUI::XREA_RETURN));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createFreeTypeFont'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::Font& tolua_ret = (CEGUI::Font&)  self->createFreeTypeFont(font_name,point_size,anti_aliased,font_filename,resource_group,auto_scaled,native_horz_res,native_vert_res,action);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Font");
 }
catch(CEGUI::AlreadyExistsException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::AlreadyExistsException' was thrown by function 'createFreeTypeFont'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 catch(CEGUI::GenericException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::GenericException' was thrown by function 'createFreeTypeFont'\nMessage: %s","Unknown");
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createFreeTypeFont'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createPixmapFont of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_createPixmapFont00
static int tolua_CEGUI_CEGUI_FontManager_createPixmapFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,1,&tolua_err) ||
 !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,7,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,8,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,9,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontManager* self = (CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string font_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string imageset_filename = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  utf8string resource_group = ((utf8string)  tolua_toutf8string(tolua_S,4,""));
  const bool auto_scaled = ((const bool)  tolua_toboolean(tolua_S,5,false));
  const float native_horz_res = ((const float)  tolua_tonumber(tolua_S,6,640.0f));
  const float native_vert_res = ((const float)  tolua_tonumber(tolua_S,7,480.0f));
  CEGUI::XMLResourceExistsAction action = ((CEGUI::XMLResourceExistsAction) (int)  tolua_tonumber(tolua_S,8,CEGUI::XREA_RETURN));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createPixmapFont'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::Font& tolua_ret = (CEGUI::Font&)  self->createPixmapFont(font_name,imageset_filename,resource_group,auto_scaled,native_horz_res,native_vert_res,action);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Font");
 }
catch(CEGUI::AlreadyExistsException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::AlreadyExistsException' was thrown by function 'createPixmapFont'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createPixmapFont'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroy of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_destroy00
static int tolua_CEGUI_CEGUI_FontManager_destroy00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontManager* self = (CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroy'",NULL);
#endif
 {
  self->destroy(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroy'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroy of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_destroy01
static int tolua_CEGUI_CEGUI_FontManager_destroy01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Font",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::FontManager* self = (CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Font* font = ((CEGUI::Font*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroy'",NULL);
#endif
 {
  self->destroy(*font);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_FontManager_destroy00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyAll of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_destroyAll00
static int tolua_CEGUI_CEGUI_FontManager_destroyAll00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontManager* self = (CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyAll'",NULL);
#endif
 {
  self->destroyAll();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyAll'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isDefined of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_isDefined00
static int tolua_CEGUI_CEGUI_FontManager_isDefined00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FontManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FontManager* self = (const CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isDefined'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isDefined(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isDefined'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_get00
static int tolua_CEGUI_CEGUI_FontManager_get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FontManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FontManager* self = (const CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  CEGUI::Font& tolua_ret = (CEGUI::Font&)  self->get(name);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Font");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: notifyDisplaySizeChanged of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_notifyDisplaySizeChanged00
static int tolua_CEGUI_CEGUI_FontManager_notifyDisplaySizeChanged00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontManager* self = (CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* sz = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'notifyDisplaySizeChanged'",NULL);
#endif
 {
  self->notifyDisplaySizeChanged(*sz);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'notifyDisplaySizeChanged'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIterator of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_getIterator00
static int tolua_CEGUI_CEGUI_FontManager_getIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FontManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FontManager* self = (const CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIterator'",NULL);
#endif
 {
  CEGUI::FontIterator tolua_ret = (CEGUI::FontIterator)  self->getIterator();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::FontIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::FontIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::FontIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::FontIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSize of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_getSize00
static int tolua_CEGUI_CEGUI_Image_getSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSize'",NULL);
#endif
 {
  CEGUI::Size tolua_ret = (CEGUI::Size)  self->getSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#endif
 }
 }
 }
 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: getWidth of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_getWidth00
static int tolua_CEGUI_CEGUI_Image_getWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWidth'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getWidth();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHeight of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_getHeight00
static int tolua_CEGUI_CEGUI_Image_getHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHeight'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getHeight();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOffsets of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_getOffsets00
static int tolua_CEGUI_CEGUI_Image_getOffsets00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOffsets'",NULL);
#endif
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  self->getOffsets();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOffsets'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOffsetX of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_getOffsetX00
static int tolua_CEGUI_CEGUI_Image_getOffsetX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOffsetX'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getOffsetX();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOffsetX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOffsetY of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_getOffsetY00
static int tolua_CEGUI_CEGUI_Image_getOffsetY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOffsetY'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getOffsetY();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOffsetY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getName of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_getName00
static int tolua_CEGUI_CEGUI_Image_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImagesetName of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_getImagesetName00
static int tolua_CEGUI_CEGUI_Image_getImagesetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImagesetName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getImagesetName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImagesetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSourceTextureArea of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_getSourceTextureArea00
static int tolua_CEGUI_CEGUI_Image_getSourceTextureArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSourceTextureArea'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getSourceTextureArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSourceTextureArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTexture of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_getTexture00
static int tolua_CEGUI_CEGUI_Imageset_getTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Imageset* self = (const CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTexture'",NULL);
#endif
 {
  CEGUI::Texture* tolua_ret = (CEGUI::Texture*)  self->getTexture();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Texture");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getName of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_getName00
static int tolua_CEGUI_CEGUI_Imageset_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Imageset* self = (const CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImageCount of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_getImageCount00
static int tolua_CEGUI_CEGUI_Imageset_getImageCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Imageset* self = (const CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImageCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getImageCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImageCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isImageDefined of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_isImageDefined00
static int tolua_CEGUI_CEGUI_Imageset_isImageDefined00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Imageset* self = (const CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isImageDefined'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isImageDefined(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isImageDefined'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImage of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_getImage00
static int tolua_CEGUI_CEGUI_Imageset_getImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Imageset* self = (const CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImage'",NULL);
#endif
 {
  const CEGUI::Image& tolua_ret = (const CEGUI::Image&)  self->getImage(name);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Image");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: undefineImage of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_undefineImage00
static int tolua_CEGUI_CEGUI_Imageset_undefineImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Imageset* self = (CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'undefineImage'",NULL);
#endif
 {
  self->undefineImage(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'undefineImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: undefineAllImages of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_undefineAllImages00
static int tolua_CEGUI_CEGUI_Imageset_undefineAllImages00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Imageset* self = (CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'undefineAllImages'",NULL);
#endif
 {
  self->undefineAllImages();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'undefineAllImages'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImageSize of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_getImageSize00
static int tolua_CEGUI_CEGUI_Imageset_getImageSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Imageset* self = (const CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImageSize'",NULL);
#endif
 {
  CEGUI::Size tolua_ret = (CEGUI::Size)  self->getImageSize(name);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImageSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImageWidth of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_getImageWidth00
static int tolua_CEGUI_CEGUI_Imageset_getImageWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Imageset* self = (const CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImageWidth'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getImageWidth(name);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImageWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImageHeight of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_getImageHeight00
static int tolua_CEGUI_CEGUI_Imageset_getImageHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Imageset* self = (const CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImageHeight'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getImageHeight(name);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImageHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImageOffset of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_getImageOffset00
static int tolua_CEGUI_CEGUI_Imageset_getImageOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Imageset* self = (const CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImageOffset'",NULL);
#endif
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  self->getImageOffset(name);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImageOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImageOffsetX of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_getImageOffsetX00
static int tolua_CEGUI_CEGUI_Imageset_getImageOffsetX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Imageset* self = (const CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImageOffsetX'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getImageOffsetX(name);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImageOffsetX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImageOffsetY of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_getImageOffsetY00
static int tolua_CEGUI_CEGUI_Imageset_getImageOffsetY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Imageset* self = (const CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImageOffsetY'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getImageOffsetY(name);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImageOffsetY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: defineImage of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_defineImage00
static int tolua_CEGUI_CEGUI_Imageset_defineImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Imageset* self = (CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  const CEGUI::Vector2* pos = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Size* size = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Vector2* render_offset = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'defineImage'",NULL);
#endif
 {
  self->defineImage(name,*pos,*size,*render_offset);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'defineImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: defineImage of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_defineImage01
static int tolua_CEGUI_CEGUI_Imageset_defineImage01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Imageset* self = (CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  const CEGUI::Rect* rect = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Vector2* render_offset = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'defineImage'",NULL);
#endif
 {
  self->defineImage(name,*rect,*render_offset);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Imageset_defineImage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setAutoScalingEnabled of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_setAutoScalingEnabled00
static int tolua_CEGUI_CEGUI_Imageset_setAutoScalingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Imageset* self = (CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoScalingEnabled'",NULL);
#endif
 {
  self->setAutoScalingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoScalingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNativeResolution of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_getNativeResolution00
static int tolua_CEGUI_CEGUI_Imageset_getNativeResolution00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Imageset* self = (const CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNativeResolution'",NULL);
#endif
 {
  CEGUI::Size tolua_ret = (CEGUI::Size)  self->getNativeResolution();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNativeResolution'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNativeResolution of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_setNativeResolution00
static int tolua_CEGUI_CEGUI_Imageset_setNativeResolution00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Imageset* self = (CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* sz = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNativeResolution'",NULL);
#endif
 {
  self->setNativeResolution(*sz);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNativeResolution'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: notifyDisplaySizeChanged of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_notifyDisplaySizeChanged00
static int tolua_CEGUI_CEGUI_Imageset_notifyDisplaySizeChanged00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Imageset* self = (CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* sz = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'notifyDisplaySizeChanged'",NULL);
#endif
 {
  self->notifyDisplaySizeChanged(*sz);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'notifyDisplaySizeChanged'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIterator of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_getIterator00
static int tolua_CEGUI_CEGUI_Imageset_getIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Imageset* self = (const CEGUI::Imageset*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIterator'",NULL);
#endif
 {
  CEGUI::ImageIterator tolua_ret = (CEGUI::ImageIterator)  self->getIterator();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::ImageIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ImageIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::ImageIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ImageIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDefaultResourceGroup of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_setDefaultResourceGroup00
static int tolua_CEGUI_CEGUI_Imageset_setDefaultResourceGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string resourceGroup = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::Imageset::setDefaultResourceGroup(resourceGroup);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDefaultResourceGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultResourceGroup of class  CEGUI::Imageset */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Imageset_getDefaultResourceGroup00
static int tolua_CEGUI_CEGUI_Imageset_getDefaultResourceGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  string tolua_ret = (string)  CEGUI::Imageset::getDefaultResourceGroup();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultResourceGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  CEGUI::ImagesetManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetManager_getSingleton00
static int tolua_CEGUI_CEGUI_ImagesetManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImagesetManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::ImagesetManager& tolua_ret = (CEGUI::ImagesetManager&)  CEGUI::ImagesetManager::getSingleton();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::ImagesetManager");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  CEGUI::ImagesetManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetManager_create00
static int tolua_CEGUI_CEGUI_ImagesetManager_create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagesetManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagesetManager* self = (CEGUI::ImagesetManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string filename = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string resourcegroup = ((utf8string)  tolua_toutf8string(tolua_S,3,""));
  CEGUI::XMLResourceExistsAction action = ((CEGUI::XMLResourceExistsAction) (int)  tolua_tonumber(tolua_S,4,CEGUI::XREA_RETURN));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::Imageset& tolua_ret = (CEGUI::Imageset&)  self->create(filename,resourcegroup,action);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Imageset");
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'create'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  CEGUI::ImagesetManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetManager_create01
static int tolua_CEGUI_CEGUI_ImagesetManager_create01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagesetManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::Texture",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ImagesetManager* self = (CEGUI::ImagesetManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::Texture* texture = ((CEGUI::Texture*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::Imageset& tolua_ret = (CEGUI::Imageset&)  self->create(name,*texture);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Imageset");
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'create'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ImagesetManager_create00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: createFromImageFile of class  CEGUI::ImagesetManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetManager_createFromImageFile00
static int tolua_CEGUI_CEGUI_ImagesetManager_createFromImageFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagesetManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagesetManager* self = (CEGUI::ImagesetManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string filename = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  utf8string resourcegroup = ((utf8string)  tolua_toutf8string(tolua_S,4,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createFromImageFile'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::Imageset& tolua_ret = (CEGUI::Imageset&)  self->createFromImageFile(name,filename,resourcegroup);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Imageset");
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'createFromImageFile'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createFromImageFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroy of class  CEGUI::ImagesetManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetManager_destroy00
static int tolua_CEGUI_CEGUI_ImagesetManager_destroy00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagesetManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Imageset",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagesetManager* self = (CEGUI::ImagesetManager*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Imageset* imageset = ((CEGUI::Imageset*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroy'",NULL);
#endif
 {
  self->destroy(*imageset);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroy'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroy of class  CEGUI::ImagesetManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetManager_destroy01
static int tolua_CEGUI_CEGUI_ImagesetManager_destroy01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagesetManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ImagesetManager* self = (CEGUI::ImagesetManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroy'",NULL);
#endif
 {
  self->destroy(name);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ImagesetManager_destroy00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyAll of class  CEGUI::ImagesetManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetManager_destroyAll00
static int tolua_CEGUI_CEGUI_ImagesetManager_destroyAll00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagesetManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagesetManager* self = (CEGUI::ImagesetManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyAll'",NULL);
#endif
 {
  self->destroyAll();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyAll'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  CEGUI::ImagesetManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetManager_get00
static int tolua_CEGUI_CEGUI_ImagesetManager_get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImagesetManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImagesetManager* self = (const CEGUI::ImagesetManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 try
 {
  CEGUI::Imageset& tolua_ret = (CEGUI::Imageset&)  self->get(name);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Imageset");
 }
catch(CEGUI::Exception CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isDefined of class  CEGUI::ImagesetManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetManager_isDefined00
static int tolua_CEGUI_CEGUI_ImagesetManager_isDefined00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImagesetManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImagesetManager* self = (const CEGUI::ImagesetManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isDefined'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isDefined(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isDefined'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: notifyDisplaySizeChanged of class  CEGUI::ImagesetManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetManager_notifyDisplaySizeChanged00
static int tolua_CEGUI_CEGUI_ImagesetManager_notifyDisplaySizeChanged00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagesetManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagesetManager* self = (CEGUI::ImagesetManager*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* size = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'notifyDisplaySizeChanged'",NULL);
#endif
 {
  self->notifyDisplaySizeChanged(*size);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'notifyDisplaySizeChanged'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIterator of class  CEGUI::ImagesetManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetManager_getIterator00
static int tolua_CEGUI_CEGUI_ImagesetManager_getIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImagesetManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImagesetManager* self = (const CEGUI::ImagesetManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIterator'",NULL);
#endif
 {
  CEGUI::ImagesetIterator tolua_ret = (CEGUI::ImagesetIterator)  self->getIterator();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::ImagesetIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ImagesetIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::ImagesetIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ImagesetIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHelp of class  CEGUI::Property */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Property_getHelp00
static int tolua_CEGUI_CEGUI_Property_getHelp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Property",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Property* self = (const CEGUI::Property*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHelp'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getHelp();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHelp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getName of class  CEGUI::Property */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Property_getName00
static int tolua_CEGUI_CEGUI_Property_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Property",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Property* self = (const CEGUI::Property*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentKey of class  CEGUI::PropertyIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyIterator_key00
static int tolua_CEGUI_CEGUI_PropertyIterator_key00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::PropertyIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PropertyIterator* self = (const CEGUI::PropertyIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentKey'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getCurrentKey();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'key'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentValue of class  CEGUI::PropertyIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyIterator_value00
static int tolua_CEGUI_CEGUI_PropertyIterator_value00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::PropertyIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PropertyIterator* self = (const CEGUI::PropertyIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentValue'",NULL);
#endif
 {
  CEGUI::Property* tolua_ret = (CEGUI::Property*)  self->getCurrentValue();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Property");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'value'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: __operator_increment of class  CEGUI::PropertyIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyIterator_next00
static int tolua_CEGUI_CEGUI_PropertyIterator_next00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PropertyIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PropertyIterator* self = (CEGUI::PropertyIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_increment'",NULL);
#endif
 {
  CEGUI::PropertyIterator& tolua_ret = (CEGUI::PropertyIterator&)  self->__operator_increment();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::PropertyIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: __operator_decrement of class  CEGUI::PropertyIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyIterator_previous00
static int tolua_CEGUI_CEGUI_PropertyIterator_previous00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PropertyIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PropertyIterator* self = (CEGUI::PropertyIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_decrement'",NULL);
#endif
 {
  CEGUI::PropertyIterator& tolua_ret = (CEGUI::PropertyIterator&)  self->__operator_decrement();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::PropertyIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'previous'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::PropertyIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyIterator__eq00
static int tolua_CEGUI_CEGUI_PropertyIterator__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::PropertyIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::PropertyIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PropertyIterator* self = (const CEGUI::PropertyIterator*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::PropertyIterator* rhs = ((const CEGUI::PropertyIterator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*rhs);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toStart of class  CEGUI::PropertyIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyIterator_toStart00
static int tolua_CEGUI_CEGUI_PropertyIterator_toStart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PropertyIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PropertyIterator* self = (CEGUI::PropertyIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toStart'",NULL);
#endif
 {
  self->toStart();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toStart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toEnd of class  CEGUI::PropertyIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyIterator_toEnd00
static int tolua_CEGUI_CEGUI_PropertyIterator_toEnd00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PropertyIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PropertyIterator* self = (CEGUI::PropertyIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toEnd'",NULL);
#endif
 {
  self->toEnd();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toEnd'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::PropertyIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyIterator_new00
static int tolua_CEGUI_CEGUI_PropertyIterator_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::PropertyIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PropertyIterator* org = ((const CEGUI::PropertyIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::PropertyIterator* tolua_ret = (CEGUI::PropertyIterator*)  new CEGUI::PropertyIterator(*org);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::PropertyIterator");
 }
 }
 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  CEGUI::PropertyIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyIterator_new00_local
static int tolua_CEGUI_CEGUI_PropertyIterator_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::PropertyIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PropertyIterator* org = ((const CEGUI::PropertyIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::PropertyIterator* tolua_ret = (CEGUI::PropertyIterator*)  new CEGUI::PropertyIterator(*org);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::PropertyIterator");
 }
 }
 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: getCurrentKey of class  CEGUI::EventIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventIterator_key00
static int tolua_CEGUI_CEGUI_EventIterator_key00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::EventIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::EventIterator* self = (const CEGUI::EventIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentKey'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getCurrentKey();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'key'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentValue of class  CEGUI::EventIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventIterator_value00
static int tolua_CEGUI_CEGUI_EventIterator_value00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::EventIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::EventIterator* self = (const CEGUI::EventIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentValue'",NULL);
#endif
 {
  CEGUI::Event* tolua_ret = (CEGUI::Event*)  self->getCurrentValue();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Event");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'value'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: __operator_increment of class  CEGUI::EventIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventIterator_next00
static int tolua_CEGUI_CEGUI_EventIterator_next00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::EventIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::EventIterator* self = (CEGUI::EventIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_increment'",NULL);
#endif
 {
  CEGUI::EventIterator& tolua_ret = (CEGUI::EventIterator&)  self->__operator_increment();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::EventIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: __operator_decrement of class  CEGUI::EventIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventIterator_previous00
static int tolua_CEGUI_CEGUI_EventIterator_previous00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::EventIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::EventIterator* self = (CEGUI::EventIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_decrement'",NULL);
#endif
 {
  CEGUI::EventIterator& tolua_ret = (CEGUI::EventIterator&)  self->__operator_decrement();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::EventIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'previous'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::EventIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventIterator__eq00
static int tolua_CEGUI_CEGUI_EventIterator__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::EventIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::EventIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::EventIterator* self = (const CEGUI::EventIterator*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::EventIterator* rhs = ((const CEGUI::EventIterator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*rhs);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toStart of class  CEGUI::EventIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventIterator_toStart00
static int tolua_CEGUI_CEGUI_EventIterator_toStart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::EventIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::EventIterator* self = (CEGUI::EventIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toStart'",NULL);
#endif
 {
  self->toStart();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toStart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toEnd of class  CEGUI::EventIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventIterator_toEnd00
static int tolua_CEGUI_CEGUI_EventIterator_toEnd00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::EventIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::EventIterator* self = (CEGUI::EventIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toEnd'",NULL);
#endif
 {
  self->toEnd();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toEnd'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::EventIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventIterator_new00
static int tolua_CEGUI_CEGUI_EventIterator_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::EventIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::EventIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::EventIterator* org = ((const CEGUI::EventIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::EventIterator* tolua_ret = (CEGUI::EventIterator*)  new CEGUI::EventIterator(*org);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::EventIterator");
 }
 }
 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  CEGUI::EventIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventIterator_new00_local
static int tolua_CEGUI_CEGUI_EventIterator_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::EventIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::EventIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::EventIterator* org = ((const CEGUI::EventIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::EventIterator* tolua_ret = (CEGUI::EventIterator*)  new CEGUI::EventIterator(*org);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::EventIterator");
 }
 }
 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: getCurrentKey of class  CEGUI::WindowIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowIterator_key00
static int tolua_CEGUI_CEGUI_WindowIterator_key00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowIterator* self = (const CEGUI::WindowIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentKey'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getCurrentKey();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'key'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentValue of class  CEGUI::WindowIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowIterator_value00
static int tolua_CEGUI_CEGUI_WindowIterator_value00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowIterator* self = (const CEGUI::WindowIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentValue'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getCurrentValue();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'value'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: __operator_increment of class  CEGUI::WindowIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowIterator_next00
static int tolua_CEGUI_CEGUI_WindowIterator_next00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowIterator* self = (CEGUI::WindowIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_increment'",NULL);
#endif
 {
  CEGUI::WindowIterator& tolua_ret = (CEGUI::WindowIterator&)  self->__operator_increment();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::WindowIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: __operator_decrement of class  CEGUI::WindowIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowIterator_previous00
static int tolua_CEGUI_CEGUI_WindowIterator_previous00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowIterator* self = (CEGUI::WindowIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_decrement'",NULL);
#endif
 {
  CEGUI::WindowIterator& tolua_ret = (CEGUI::WindowIterator&)  self->__operator_decrement();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::WindowIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'previous'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::WindowIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowIterator__eq00
static int tolua_CEGUI_CEGUI_WindowIterator__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::WindowIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowIterator* self = (const CEGUI::WindowIterator*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::WindowIterator* rhs = ((const CEGUI::WindowIterator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*rhs);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toStart of class  CEGUI::WindowIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowIterator_toStart00
static int tolua_CEGUI_CEGUI_WindowIterator_toStart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowIterator* self = (CEGUI::WindowIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toStart'",NULL);
#endif
 {
  self->toStart();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toStart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toEnd of class  CEGUI::WindowIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowIterator_toEnd00
static int tolua_CEGUI_CEGUI_WindowIterator_toEnd00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowIterator* self = (CEGUI::WindowIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toEnd'",NULL);
#endif
 {
  self->toEnd();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toEnd'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::WindowIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowIterator_new00
static int tolua_CEGUI_CEGUI_WindowIterator_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WindowIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::WindowIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowIterator* org = ((const CEGUI::WindowIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::WindowIterator* tolua_ret = (CEGUI::WindowIterator*)  new CEGUI::WindowIterator(*org);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::WindowIterator");
 }
 }
 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  CEGUI::WindowIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowIterator_new00_local
static int tolua_CEGUI_CEGUI_WindowIterator_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WindowIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::WindowIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowIterator* org = ((const CEGUI::WindowIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::WindowIterator* tolua_ret = (CEGUI::WindowIterator*)  new CEGUI::WindowIterator(*org);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::WindowIterator");
 }
 }
 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: getCurrentKey of class  CEGUI::WindowFactoryIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryIterator_key00
static int tolua_CEGUI_CEGUI_WindowFactoryIterator_key00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowFactoryIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactoryIterator* self = (const CEGUI::WindowFactoryIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentKey'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getCurrentKey();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'key'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentValue of class  CEGUI::WindowFactoryIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryIterator_value00
static int tolua_CEGUI_CEGUI_WindowFactoryIterator_value00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowFactoryIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactoryIterator* self = (const CEGUI::WindowFactoryIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentValue'",NULL);
#endif
 {
  CEGUI::WindowFactory* tolua_ret = (CEGUI::WindowFactory*)  self->getCurrentValue();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::WindowFactory");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'value'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: __operator_increment of class  CEGUI::WindowFactoryIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryIterator_next00
static int tolua_CEGUI_CEGUI_WindowFactoryIterator_next00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowFactoryIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowFactoryIterator* self = (CEGUI::WindowFactoryIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_increment'",NULL);
#endif
 {
  CEGUI::WindowFactoryIterator& tolua_ret = (CEGUI::WindowFactoryIterator&)  self->__operator_increment();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::WindowFactoryIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: __operator_decrement of class  CEGUI::WindowFactoryIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryIterator_previous00
static int tolua_CEGUI_CEGUI_WindowFactoryIterator_previous00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowFactoryIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowFactoryIterator* self = (CEGUI::WindowFactoryIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_decrement'",NULL);
#endif
 {
  CEGUI::WindowFactoryIterator& tolua_ret = (CEGUI::WindowFactoryIterator&)  self->__operator_decrement();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::WindowFactoryIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'previous'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::WindowFactoryIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryIterator__eq00
static int tolua_CEGUI_CEGUI_WindowFactoryIterator__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowFactoryIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::WindowFactoryIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactoryIterator* self = (const CEGUI::WindowFactoryIterator*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::WindowFactoryIterator* rhs = ((const CEGUI::WindowFactoryIterator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*rhs);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toStart of class  CEGUI::WindowFactoryIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryIterator_toStart00
static int tolua_CEGUI_CEGUI_WindowFactoryIterator_toStart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowFactoryIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowFactoryIterator* self = (CEGUI::WindowFactoryIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toStart'",NULL);
#endif
 {
  self->toStart();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toStart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toEnd of class  CEGUI::WindowFactoryIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryIterator_toEnd00
static int tolua_CEGUI_CEGUI_WindowFactoryIterator_toEnd00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowFactoryIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowFactoryIterator* self = (CEGUI::WindowFactoryIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toEnd'",NULL);
#endif
 {
  self->toEnd();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toEnd'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::WindowFactoryIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryIterator_new00
static int tolua_CEGUI_CEGUI_WindowFactoryIterator_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WindowFactoryIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::WindowFactoryIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactoryIterator* org = ((const CEGUI::WindowFactoryIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::WindowFactoryIterator* tolua_ret = (CEGUI::WindowFactoryIterator*)  new CEGUI::WindowFactoryIterator(*org);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::WindowFactoryIterator");
 }
 }
 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  CEGUI::WindowFactoryIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryIterator_new00_local
static int tolua_CEGUI_CEGUI_WindowFactoryIterator_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WindowFactoryIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::WindowFactoryIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactoryIterator* org = ((const CEGUI::WindowFactoryIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::WindowFactoryIterator* tolua_ret = (CEGUI::WindowFactoryIterator*)  new CEGUI::WindowFactoryIterator(*org);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::WindowFactoryIterator");
 }
 }
 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: getCurrentKey of class  CEGUI::FalagardMappingIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardMappingIterator_key00
static int tolua_CEGUI_CEGUI_FalagardMappingIterator_key00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FalagardMappingIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FalagardMappingIterator* self = (const CEGUI::FalagardMappingIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentKey'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getCurrentKey();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'key'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentValue of class  CEGUI::FalagardMappingIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardMappingIterator_value00
static int tolua_CEGUI_CEGUI_FalagardMappingIterator_value00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FalagardMappingIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FalagardMappingIterator* self = (const CEGUI::FalagardMappingIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentValue'",NULL);
#endif
 {
  CEGUI::FalagardWindowMapping tolua_ret = (CEGUI::FalagardWindowMapping)  self->getCurrentValue();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::FalagardWindowMapping(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::FalagardWindowMapping");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::FalagardWindowMapping));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::FalagardWindowMapping");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'value'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: __operator_increment of class  CEGUI::FalagardMappingIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardMappingIterator_next00
static int tolua_CEGUI_CEGUI_FalagardMappingIterator_next00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FalagardMappingIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FalagardMappingIterator* self = (CEGUI::FalagardMappingIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_increment'",NULL);
#endif
 {
  CEGUI::FalagardMappingIterator& tolua_ret = (CEGUI::FalagardMappingIterator&)  self->__operator_increment();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::FalagardMappingIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: __operator_decrement of class  CEGUI::FalagardMappingIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardMappingIterator_previous00
static int tolua_CEGUI_CEGUI_FalagardMappingIterator_previous00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FalagardMappingIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FalagardMappingIterator* self = (CEGUI::FalagardMappingIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_decrement'",NULL);
#endif
 {
  CEGUI::FalagardMappingIterator& tolua_ret = (CEGUI::FalagardMappingIterator&)  self->__operator_decrement();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::FalagardMappingIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'previous'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::FalagardMappingIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardMappingIterator__eq00
static int tolua_CEGUI_CEGUI_FalagardMappingIterator__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FalagardMappingIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::FalagardMappingIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FalagardMappingIterator* self = (const CEGUI::FalagardMappingIterator*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::FalagardMappingIterator* rhs = ((const CEGUI::FalagardMappingIterator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*rhs);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toStart of class  CEGUI::FalagardMappingIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardMappingIterator_toStart00
static int tolua_CEGUI_CEGUI_FalagardMappingIterator_toStart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FalagardMappingIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FalagardMappingIterator* self = (CEGUI::FalagardMappingIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toStart'",NULL);
#endif
 {
  self->toStart();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toStart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toEnd of class  CEGUI::FalagardMappingIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardMappingIterator_toEnd00
static int tolua_CEGUI_CEGUI_FalagardMappingIterator_toEnd00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FalagardMappingIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FalagardMappingIterator* self = (CEGUI::FalagardMappingIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toEnd'",NULL);
#endif
 {
  self->toEnd();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toEnd'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::FalagardMappingIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardMappingIterator_new00
static int tolua_CEGUI_CEGUI_FalagardMappingIterator_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::FalagardMappingIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::FalagardMappingIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FalagardMappingIterator* org = ((const CEGUI::FalagardMappingIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::FalagardMappingIterator* tolua_ret = (CEGUI::FalagardMappingIterator*)  new CEGUI::FalagardMappingIterator(*org);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::FalagardMappingIterator");
 }
 }
 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  CEGUI::FalagardMappingIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardMappingIterator_new00_local
static int tolua_CEGUI_CEGUI_FalagardMappingIterator_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::FalagardMappingIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::FalagardMappingIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FalagardMappingIterator* org = ((const CEGUI::FalagardMappingIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::FalagardMappingIterator* tolua_ret = (CEGUI::FalagardMappingIterator*)  new CEGUI::FalagardMappingIterator(*org);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::FalagardMappingIterator");
 }
 }
 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: getCurrentKey of class  CEGUI::ImagesetIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetIterator_key00
static int tolua_CEGUI_CEGUI_ImagesetIterator_key00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImagesetIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImagesetIterator* self = (const CEGUI::ImagesetIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentKey'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getCurrentKey();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'key'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentValue of class  CEGUI::ImagesetIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetIterator_value00
static int tolua_CEGUI_CEGUI_ImagesetIterator_value00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImagesetIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImagesetIterator* self = (const CEGUI::ImagesetIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentValue'",NULL);
#endif
 {
  CEGUI::Imageset* tolua_ret = (CEGUI::Imageset*)  self->getCurrentValue();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Imageset");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'value'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: __operator_increment of class  CEGUI::ImagesetIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetIterator_next00
static int tolua_CEGUI_CEGUI_ImagesetIterator_next00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagesetIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagesetIterator* self = (CEGUI::ImagesetIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_increment'",NULL);
#endif
 {
  CEGUI::ImagesetIterator& tolua_ret = (CEGUI::ImagesetIterator&)  self->__operator_increment();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::ImagesetIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: __operator_decrement of class  CEGUI::ImagesetIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetIterator_previous00
static int tolua_CEGUI_CEGUI_ImagesetIterator_previous00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagesetIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagesetIterator* self = (CEGUI::ImagesetIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_decrement'",NULL);
#endif
 {
  CEGUI::ImagesetIterator& tolua_ret = (CEGUI::ImagesetIterator&)  self->__operator_decrement();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::ImagesetIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'previous'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::ImagesetIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetIterator__eq00
static int tolua_CEGUI_CEGUI_ImagesetIterator__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImagesetIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ImagesetIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImagesetIterator* self = (const CEGUI::ImagesetIterator*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ImagesetIterator* rhs = ((const CEGUI::ImagesetIterator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*rhs);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toStart of class  CEGUI::ImagesetIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetIterator_toStart00
static int tolua_CEGUI_CEGUI_ImagesetIterator_toStart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagesetIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagesetIterator* self = (CEGUI::ImagesetIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toStart'",NULL);
#endif
 {
  self->toStart();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toStart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toEnd of class  CEGUI::ImagesetIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetIterator_toEnd00
static int tolua_CEGUI_CEGUI_ImagesetIterator_toEnd00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagesetIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagesetIterator* self = (CEGUI::ImagesetIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toEnd'",NULL);
#endif
 {
  self->toEnd();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toEnd'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::ImagesetIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetIterator_new00
static int tolua_CEGUI_CEGUI_ImagesetIterator_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImagesetIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ImagesetIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImagesetIterator* org = ((const CEGUI::ImagesetIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::ImagesetIterator* tolua_ret = (CEGUI::ImagesetIterator*)  new CEGUI::ImagesetIterator(*org);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ImagesetIterator");
 }
 }
 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  CEGUI::ImagesetIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagesetIterator_new00_local
static int tolua_CEGUI_CEGUI_ImagesetIterator_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImagesetIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ImagesetIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImagesetIterator* org = ((const CEGUI::ImagesetIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::ImagesetIterator* tolua_ret = (CEGUI::ImagesetIterator*)  new CEGUI::ImagesetIterator(*org);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::ImagesetIterator");
 }
 }
 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: getCurrentKey of class  CEGUI::ImageIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageIterator_key00
static int tolua_CEGUI_CEGUI_ImageIterator_key00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageIterator* self = (const CEGUI::ImageIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentKey'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getCurrentKey();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'key'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentValue of class  CEGUI::ImageIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageIterator_value00
static int tolua_CEGUI_CEGUI_ImageIterator_value00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageIterator* self = (const CEGUI::ImageIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentValue'",NULL);
#endif
 {
  CEGUI::Image tolua_ret = (CEGUI::Image)  self->getCurrentValue();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Image(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Image");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Image));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Image");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'value'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: __operator_increment of class  CEGUI::ImageIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageIterator_next00
static int tolua_CEGUI_CEGUI_ImageIterator_next00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageIterator* self = (CEGUI::ImageIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_increment'",NULL);
#endif
 {
  CEGUI::ImageIterator& tolua_ret = (CEGUI::ImageIterator&)  self->__operator_increment();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::ImageIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: __operator_decrement of class  CEGUI::ImageIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageIterator_previous00
static int tolua_CEGUI_CEGUI_ImageIterator_previous00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageIterator* self = (CEGUI::ImageIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_decrement'",NULL);
#endif
 {
  CEGUI::ImageIterator& tolua_ret = (CEGUI::ImageIterator&)  self->__operator_decrement();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::ImageIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'previous'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::ImageIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageIterator__eq00
static int tolua_CEGUI_CEGUI_ImageIterator__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ImageIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageIterator* self = (const CEGUI::ImageIterator*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ImageIterator* rhs = ((const CEGUI::ImageIterator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*rhs);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toStart of class  CEGUI::ImageIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageIterator_toStart00
static int tolua_CEGUI_CEGUI_ImageIterator_toStart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageIterator* self = (CEGUI::ImageIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toStart'",NULL);
#endif
 {
  self->toStart();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toStart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toEnd of class  CEGUI::ImageIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageIterator_toEnd00
static int tolua_CEGUI_CEGUI_ImageIterator_toEnd00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageIterator* self = (CEGUI::ImageIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toEnd'",NULL);
#endif
 {
  self->toEnd();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toEnd'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::ImageIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageIterator_new00
static int tolua_CEGUI_CEGUI_ImageIterator_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImageIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ImageIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageIterator* org = ((const CEGUI::ImageIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::ImageIterator* tolua_ret = (CEGUI::ImageIterator*)  new CEGUI::ImageIterator(*org);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ImageIterator");
 }
 }
 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  CEGUI::ImageIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageIterator_new00_local
static int tolua_CEGUI_CEGUI_ImageIterator_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImageIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ImageIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageIterator* org = ((const CEGUI::ImageIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::ImageIterator* tolua_ret = (CEGUI::ImageIterator*)  new CEGUI::ImageIterator(*org);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::ImageIterator");
 }
 }
 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: getCurrentKey of class  CEGUI::SchemeIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeIterator_key00
static int tolua_CEGUI_CEGUI_SchemeIterator_key00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SchemeIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SchemeIterator* self = (const CEGUI::SchemeIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentKey'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getCurrentKey();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'key'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentValue of class  CEGUI::SchemeIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeIterator_value00
static int tolua_CEGUI_CEGUI_SchemeIterator_value00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SchemeIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SchemeIterator* self = (const CEGUI::SchemeIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentValue'",NULL);
#endif
 {
  CEGUI::Scheme* tolua_ret = (CEGUI::Scheme*)  self->getCurrentValue();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Scheme");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'value'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: __operator_increment of class  CEGUI::SchemeIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeIterator_next00
static int tolua_CEGUI_CEGUI_SchemeIterator_next00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SchemeIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SchemeIterator* self = (CEGUI::SchemeIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_increment'",NULL);
#endif
 {
  CEGUI::SchemeIterator& tolua_ret = (CEGUI::SchemeIterator&)  self->__operator_increment();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::SchemeIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: __operator_decrement of class  CEGUI::SchemeIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeIterator_previous00
static int tolua_CEGUI_CEGUI_SchemeIterator_previous00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SchemeIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SchemeIterator* self = (CEGUI::SchemeIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_decrement'",NULL);
#endif
 {
  CEGUI::SchemeIterator& tolua_ret = (CEGUI::SchemeIterator&)  self->__operator_decrement();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::SchemeIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'previous'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::SchemeIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeIterator__eq00
static int tolua_CEGUI_CEGUI_SchemeIterator__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SchemeIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::SchemeIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SchemeIterator* self = (const CEGUI::SchemeIterator*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::SchemeIterator* rhs = ((const CEGUI::SchemeIterator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*rhs);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toStart of class  CEGUI::SchemeIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeIterator_toStart00
static int tolua_CEGUI_CEGUI_SchemeIterator_toStart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SchemeIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SchemeIterator* self = (CEGUI::SchemeIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toStart'",NULL);
#endif
 {
  self->toStart();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toStart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toEnd of class  CEGUI::SchemeIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeIterator_toEnd00
static int tolua_CEGUI_CEGUI_SchemeIterator_toEnd00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SchemeIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SchemeIterator* self = (CEGUI::SchemeIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toEnd'",NULL);
#endif
 {
  self->toEnd();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toEnd'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::SchemeIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeIterator_new00
static int tolua_CEGUI_CEGUI_SchemeIterator_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::SchemeIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::SchemeIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SchemeIterator* org = ((const CEGUI::SchemeIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::SchemeIterator* tolua_ret = (CEGUI::SchemeIterator*)  new CEGUI::SchemeIterator(*org);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::SchemeIterator");
 }
 }
 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  CEGUI::SchemeIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeIterator_new00_local
static int tolua_CEGUI_CEGUI_SchemeIterator_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::SchemeIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::SchemeIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SchemeIterator* org = ((const CEGUI::SchemeIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::SchemeIterator* tolua_ret = (CEGUI::SchemeIterator*)  new CEGUI::SchemeIterator(*org);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::SchemeIterator");
 }
 }
 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: getCurrentKey of class  CEGUI::FontIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontIterator_key00
static int tolua_CEGUI_CEGUI_FontIterator_key00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FontIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FontIterator* self = (const CEGUI::FontIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentKey'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getCurrentKey();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'key'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentValue of class  CEGUI::FontIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontIterator_value00
static int tolua_CEGUI_CEGUI_FontIterator_value00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FontIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FontIterator* self = (const CEGUI::FontIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentValue'",NULL);
#endif
 {
  CEGUI::Font* tolua_ret = (CEGUI::Font*)  self->getCurrentValue();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Font");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'value'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: __operator_increment of class  CEGUI::FontIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontIterator_next00
static int tolua_CEGUI_CEGUI_FontIterator_next00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontIterator* self = (CEGUI::FontIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_increment'",NULL);
#endif
 {
  CEGUI::FontIterator& tolua_ret = (CEGUI::FontIterator&)  self->__operator_increment();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::FontIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: __operator_decrement of class  CEGUI::FontIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontIterator_previous00
static int tolua_CEGUI_CEGUI_FontIterator_previous00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontIterator* self = (CEGUI::FontIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function '__operator_decrement'",NULL);
#endif
 {
  CEGUI::FontIterator& tolua_ret = (CEGUI::FontIterator&)  self->__operator_decrement();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::FontIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'previous'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::FontIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontIterator__eq00
static int tolua_CEGUI_CEGUI_FontIterator__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FontIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::FontIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FontIterator* self = (const CEGUI::FontIterator*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::FontIterator* rhs = ((const CEGUI::FontIterator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*rhs);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toStart of class  CEGUI::FontIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontIterator_toStart00
static int tolua_CEGUI_CEGUI_FontIterator_toStart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontIterator* self = (CEGUI::FontIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toStart'",NULL);
#endif
 {
  self->toStart();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toStart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toEnd of class  CEGUI::FontIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontIterator_toEnd00
static int tolua_CEGUI_CEGUI_FontIterator_toEnd00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontIterator* self = (CEGUI::FontIterator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toEnd'",NULL);
#endif
 {
  self->toEnd();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toEnd'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::FontIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontIterator_new00
static int tolua_CEGUI_CEGUI_FontIterator_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::FontIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::FontIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FontIterator* org = ((const CEGUI::FontIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::FontIterator* tolua_ret = (CEGUI::FontIterator*)  new CEGUI::FontIterator(*org);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::FontIterator");
 }
 }
 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  CEGUI::FontIterator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontIterator_new00_local
static int tolua_CEGUI_CEGUI_FontIterator_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::FontIterator",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::FontIterator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FontIterator* org = ((const CEGUI::FontIterator*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::FontIterator* tolua_ret = (CEGUI::FontIterator*)  new CEGUI::FontIterator(*org);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::FontIterator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: handled of class  CEGUI::EventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__EventArgs_unsigned_handled
static int tolua_get_CEGUI__EventArgs_unsigned_handled(lua_State* tolua_S)
{
  CEGUI::EventArgs* self = (CEGUI::EventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'handled'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->handled);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: handled of class  CEGUI::EventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__EventArgs_unsigned_handled
static int tolua_set_CEGUI__EventArgs_unsigned_handled(lua_State* tolua_S)
{
  CEGUI::EventArgs* self = (CEGUI::EventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'handled'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->handled = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::EventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventArgs_new00
static int tolua_CEGUI_CEGUI_EventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::EventArgs",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::EventArgs* tolua_ret = (CEGUI::EventArgs*)  new CEGUI::EventArgs();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::EventArgs");
 }
 }
 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  CEGUI::EventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventArgs_new00_local
static int tolua_CEGUI_CEGUI_EventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::EventArgs",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::EventArgs* tolua_ret = (CEGUI::EventArgs*)  new CEGUI::EventArgs();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::EventArgs");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: mouseCursor of class  CEGUI::MouseCursorEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__MouseCursorEventArgs_mouseCursor_ptr
static int tolua_get_CEGUI__MouseCursorEventArgs_mouseCursor_ptr(lua_State* tolua_S)
{
  CEGUI::MouseCursorEventArgs* self = (CEGUI::MouseCursorEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'mouseCursor'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)self->mouseCursor,"CEGUI::MouseCursor");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: mouseCursor of class  CEGUI::MouseCursorEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__MouseCursorEventArgs_mouseCursor_ptr
static int tolua_set_CEGUI__MouseCursorEventArgs_mouseCursor_ptr(lua_State* tolua_S)
{
  CEGUI::MouseCursorEventArgs* self = (CEGUI::MouseCursorEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'mouseCursor'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::MouseCursor",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->mouseCursor = ((CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: image of class  CEGUI::MouseCursorEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__MouseCursorEventArgs_image_ptr
static int tolua_get_CEGUI__MouseCursorEventArgs_image_ptr(lua_State* tolua_S)
{
  CEGUI::MouseCursorEventArgs* self = (CEGUI::MouseCursorEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'image'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)self->image,"const CEGUI::Image");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::MouseCursorEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursorEventArgs_new00
static int tolua_CEGUI_CEGUI_MouseCursorEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::MouseCursorEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MouseCursor* cursor = ((CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::MouseCursorEventArgs* tolua_ret = (CEGUI::MouseCursorEventArgs*)  new CEGUI::MouseCursorEventArgs(cursor);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::MouseCursorEventArgs");
 }
 }
 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  CEGUI::MouseCursorEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursorEventArgs_new00_local
static int tolua_CEGUI_CEGUI_MouseCursorEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::MouseCursorEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MouseCursor* cursor = ((CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::MouseCursorEventArgs* tolua_ret = (CEGUI::MouseCursorEventArgs*)  new CEGUI::MouseCursorEventArgs(cursor);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::MouseCursorEventArgs");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: window of class  CEGUI::WindowEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__WindowEventArgs_window_ptr
static int tolua_get_CEGUI__WindowEventArgs_window_ptr(lua_State* tolua_S)
{
  CEGUI::WindowEventArgs* self = (CEGUI::WindowEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'window'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)self->window,"CEGUI::Window");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: window of class  CEGUI::WindowEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__WindowEventArgs_window_ptr
static int tolua_set_CEGUI__WindowEventArgs_window_ptr(lua_State* tolua_S)
{
  CEGUI::WindowEventArgs* self = (CEGUI::WindowEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'window'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->window = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::WindowEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowEventArgs_new00
static int tolua_CEGUI_CEGUI_WindowEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WindowEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::WindowEventArgs* tolua_ret = (CEGUI::WindowEventArgs*)  new CEGUI::WindowEventArgs(wnd);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::WindowEventArgs");
 }
 }
 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  CEGUI::WindowEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowEventArgs_new00_local
static int tolua_CEGUI_CEGUI_WindowEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WindowEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::WindowEventArgs* tolua_ret = (CEGUI::WindowEventArgs*)  new CEGUI::WindowEventArgs(wnd);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::WindowEventArgs");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: otherWindow of class  CEGUI::ActivationEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__ActivationEventArgs_otherWindow_ptr
static int tolua_get_CEGUI__ActivationEventArgs_otherWindow_ptr(lua_State* tolua_S)
{
  CEGUI::ActivationEventArgs* self = (CEGUI::ActivationEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'otherWindow'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)self->otherWindow,"CEGUI::Window");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: otherWindow of class  CEGUI::ActivationEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__ActivationEventArgs_otherWindow_ptr
static int tolua_set_CEGUI__ActivationEventArgs_otherWindow_ptr(lua_State* tolua_S)
{
  CEGUI::ActivationEventArgs* self = (CEGUI::ActivationEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'otherWindow'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->otherWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::ActivationEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ActivationEventArgs_new00
static int tolua_CEGUI_CEGUI_ActivationEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ActivationEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::ActivationEventArgs* tolua_ret = (CEGUI::ActivationEventArgs*)  new CEGUI::ActivationEventArgs(wnd);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ActivationEventArgs");
 }
 }
 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  CEGUI::ActivationEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ActivationEventArgs_new00_local
static int tolua_CEGUI_CEGUI_ActivationEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ActivationEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::ActivationEventArgs* tolua_ret = (CEGUI::ActivationEventArgs*)  new CEGUI::ActivationEventArgs(wnd);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::ActivationEventArgs");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_oldIdx of class  CEGUI::HeaderSequenceEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__HeaderSequenceEventArgs_unsigned_oldIdx
static int tolua_get_CEGUI__HeaderSequenceEventArgs_unsigned_oldIdx(lua_State* tolua_S)
{
  CEGUI::HeaderSequenceEventArgs* self = (CEGUI::HeaderSequenceEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_oldIdx'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_oldIdx);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_oldIdx of class  CEGUI::HeaderSequenceEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__HeaderSequenceEventArgs_unsigned_oldIdx
static int tolua_set_CEGUI__HeaderSequenceEventArgs_unsigned_oldIdx(lua_State* tolua_S)
{
  CEGUI::HeaderSequenceEventArgs* self = (CEGUI::HeaderSequenceEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_oldIdx'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_oldIdx = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_newIdx of class  CEGUI::HeaderSequenceEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__HeaderSequenceEventArgs_unsigned_newIdx
static int tolua_get_CEGUI__HeaderSequenceEventArgs_unsigned_newIdx(lua_State* tolua_S)
{
  CEGUI::HeaderSequenceEventArgs* self = (CEGUI::HeaderSequenceEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_newIdx'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->d_newIdx);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_newIdx of class  CEGUI::HeaderSequenceEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__HeaderSequenceEventArgs_unsigned_newIdx
static int tolua_set_CEGUI__HeaderSequenceEventArgs_unsigned_newIdx(lua_State* tolua_S)
{
  CEGUI::HeaderSequenceEventArgs* self = (CEGUI::HeaderSequenceEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_newIdx'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_newIdx = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::HeaderSequenceEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_HeaderSequenceEventArgs_new00
static int tolua_CEGUI_CEGUI_HeaderSequenceEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::HeaderSequenceEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  unsigned int old_index = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  unsigned int new_index = ((unsigned int)  tolua_tonumber(tolua_S,4,0));
 {
  CEGUI::HeaderSequenceEventArgs* tolua_ret = (CEGUI::HeaderSequenceEventArgs*)  new CEGUI::HeaderSequenceEventArgs(wnd,old_index,new_index);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::HeaderSequenceEventArgs");
 }
 }
 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  CEGUI::HeaderSequenceEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_HeaderSequenceEventArgs_new00_local
static int tolua_CEGUI_CEGUI_HeaderSequenceEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::HeaderSequenceEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  unsigned int old_index = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  unsigned int new_index = ((unsigned int)  tolua_tonumber(tolua_S,4,0));
 {
  CEGUI::HeaderSequenceEventArgs* tolua_ret = (CEGUI::HeaderSequenceEventArgs*)  new CEGUI::HeaderSequenceEventArgs(wnd,old_index,new_index);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::HeaderSequenceEventArgs");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: position of class  CEGUI::MouseEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__MouseEventArgs_position
static int tolua_get_CEGUI__MouseEventArgs_position(lua_State* tolua_S)
{
  CEGUI::MouseEventArgs* self = (CEGUI::MouseEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'position'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->position,"CEGUI::Vector2");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: position of class  CEGUI::MouseEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__MouseEventArgs_position
static int tolua_set_CEGUI__MouseEventArgs_position(lua_State* tolua_S)
{
  CEGUI::MouseEventArgs* self = (CEGUI::MouseEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'position'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::Vector2",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->position = *((CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: moveDelta of class  CEGUI::MouseEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__MouseEventArgs_moveDelta
static int tolua_get_CEGUI__MouseEventArgs_moveDelta(lua_State* tolua_S)
{
  CEGUI::MouseEventArgs* self = (CEGUI::MouseEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'moveDelta'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->moveDelta,"CEGUI::Vector2");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: moveDelta of class  CEGUI::MouseEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__MouseEventArgs_moveDelta
static int tolua_set_CEGUI__MouseEventArgs_moveDelta(lua_State* tolua_S)
{
  CEGUI::MouseEventArgs* self = (CEGUI::MouseEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'moveDelta'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::Vector2",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->moveDelta = *((CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: button of class  CEGUI::MouseEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__MouseEventArgs_button
static int tolua_get_CEGUI__MouseEventArgs_button(lua_State* tolua_S)
{
  CEGUI::MouseEventArgs* self = (CEGUI::MouseEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'button'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->button);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: button of class  CEGUI::MouseEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__MouseEventArgs_button
static int tolua_set_CEGUI__MouseEventArgs_button(lua_State* tolua_S)
{
  CEGUI::MouseEventArgs* self = (CEGUI::MouseEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'button'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->button = ((CEGUI::MouseButton) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: sysKeys of class  CEGUI::MouseEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__MouseEventArgs_unsigned_sysKeys
static int tolua_get_CEGUI__MouseEventArgs_unsigned_sysKeys(lua_State* tolua_S)
{
  CEGUI::MouseEventArgs* self = (CEGUI::MouseEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'sysKeys'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->sysKeys);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: sysKeys of class  CEGUI::MouseEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__MouseEventArgs_unsigned_sysKeys
static int tolua_set_CEGUI__MouseEventArgs_unsigned_sysKeys(lua_State* tolua_S)
{
  CEGUI::MouseEventArgs* self = (CEGUI::MouseEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'sysKeys'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->sysKeys = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: wheelChange of class  CEGUI::MouseEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__MouseEventArgs_wheelChange
static int tolua_get_CEGUI__MouseEventArgs_wheelChange(lua_State* tolua_S)
{
  CEGUI::MouseEventArgs* self = (CEGUI::MouseEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'wheelChange'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->wheelChange);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: wheelChange of class  CEGUI::MouseEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__MouseEventArgs_wheelChange
static int tolua_set_CEGUI__MouseEventArgs_wheelChange(lua_State* tolua_S)
{
  CEGUI::MouseEventArgs* self = (CEGUI::MouseEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'wheelChange'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->wheelChange = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::MouseEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseEventArgs_new00
static int tolua_CEGUI_CEGUI_MouseEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::MouseEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::MouseEventArgs* tolua_ret = (CEGUI::MouseEventArgs*)  new CEGUI::MouseEventArgs(wnd);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::MouseEventArgs");
 }
 }
 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  CEGUI::MouseEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseEventArgs_new00_local
static int tolua_CEGUI_CEGUI_MouseEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::MouseEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::MouseEventArgs* tolua_ret = (CEGUI::MouseEventArgs*)  new CEGUI::MouseEventArgs(wnd);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::MouseEventArgs");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: codepoint of class  CEGUI::KeyEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__KeyEventArgs_unsigned_codepoint
static int tolua_get_CEGUI__KeyEventArgs_unsigned_codepoint(lua_State* tolua_S)
{
  CEGUI::KeyEventArgs* self = (CEGUI::KeyEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'codepoint'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->codepoint);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: codepoint of class  CEGUI::KeyEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__KeyEventArgs_unsigned_codepoint
static int tolua_set_CEGUI__KeyEventArgs_unsigned_codepoint(lua_State* tolua_S)
{
  CEGUI::KeyEventArgs* self = (CEGUI::KeyEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'codepoint'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->codepoint = ((unsigned long)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: scancode of class  CEGUI::KeyEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__KeyEventArgs_scancode
static int tolua_get_CEGUI__KeyEventArgs_scancode(lua_State* tolua_S)
{
  CEGUI::KeyEventArgs* self = (CEGUI::KeyEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'scancode'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->scancode);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: scancode of class  CEGUI::KeyEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__KeyEventArgs_scancode
static int tolua_set_CEGUI__KeyEventArgs_scancode(lua_State* tolua_S)
{
  CEGUI::KeyEventArgs* self = (CEGUI::KeyEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'scancode'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->scancode = ((CEGUI::Key::Scan) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: sysKeys of class  CEGUI::KeyEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__KeyEventArgs_unsigned_sysKeys
static int tolua_get_CEGUI__KeyEventArgs_unsigned_sysKeys(lua_State* tolua_S)
{
  CEGUI::KeyEventArgs* self = (CEGUI::KeyEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'sysKeys'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->sysKeys);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: sysKeys of class  CEGUI::KeyEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__KeyEventArgs_unsigned_sysKeys
static int tolua_set_CEGUI__KeyEventArgs_unsigned_sysKeys(lua_State* tolua_S)
{
  CEGUI::KeyEventArgs* self = (CEGUI::KeyEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'sysKeys'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->sysKeys = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::KeyEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_KeyEventArgs_new00
static int tolua_CEGUI_CEGUI_KeyEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::KeyEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::KeyEventArgs* tolua_ret = (CEGUI::KeyEventArgs*)  new CEGUI::KeyEventArgs(wnd);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::KeyEventArgs");
 }
 }
 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  CEGUI::KeyEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_KeyEventArgs_new00_local
static int tolua_CEGUI_CEGUI_KeyEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::KeyEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::KeyEventArgs* tolua_ret = (CEGUI::KeyEventArgs*)  new CEGUI::KeyEventArgs(wnd);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::KeyEventArgs");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: dragDropItem of class  CEGUI::DragDropEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__DragDropEventArgs_dragDropItem_ptr
static int tolua_get_CEGUI__DragDropEventArgs_dragDropItem_ptr(lua_State* tolua_S)
{
  CEGUI::DragDropEventArgs* self = (CEGUI::DragDropEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'dragDropItem'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)self->dragDropItem,"CEGUI::DragContainer");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: dragDropItem of class  CEGUI::DragDropEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__DragDropEventArgs_dragDropItem_ptr
static int tolua_set_CEGUI__DragDropEventArgs_dragDropItem_ptr(lua_State* tolua_S)
{
  CEGUI::DragDropEventArgs* self = (CEGUI::DragDropEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'dragDropItem'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::DragContainer",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->dragDropItem = ((CEGUI::DragContainer*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::DragDropEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragDropEventArgs_new00
static int tolua_CEGUI_CEGUI_DragDropEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::DragDropEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::DragDropEventArgs* tolua_ret = (CEGUI::DragDropEventArgs*)  new CEGUI::DragDropEventArgs(wnd);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::DragDropEventArgs");
 }
 }
 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  CEGUI::DragDropEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragDropEventArgs_new00_local
static int tolua_CEGUI_CEGUI_DragDropEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::DragDropEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::DragDropEventArgs* tolua_ret = (CEGUI::DragDropEventArgs*)  new CEGUI::DragDropEventArgs(wnd);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::DragDropEventArgs");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: treeItem of class  CEGUI::TreeEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__TreeEventArgs_treeItem_ptr
static int tolua_get_CEGUI__TreeEventArgs_treeItem_ptr(lua_State* tolua_S)
{
  CEGUI::TreeEventArgs* self = (CEGUI::TreeEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'treeItem'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)self->treeItem,"CEGUI::TreeItem");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: treeItem of class  CEGUI::TreeEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__TreeEventArgs_treeItem_ptr
static int tolua_set_CEGUI__TreeEventArgs_treeItem_ptr(lua_State* tolua_S)
{
  CEGUI::TreeEventArgs* self = (CEGUI::TreeEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'treeItem'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::TreeItem",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->treeItem = ((CEGUI::TreeItem*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::TreeEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeEventArgs_new00
static int tolua_CEGUI_CEGUI_TreeEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::TreeEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::TreeEventArgs* tolua_ret = (CEGUI::TreeEventArgs*)  new CEGUI::TreeEventArgs(wnd);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TreeEventArgs");
 }
 }
 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  CEGUI::TreeEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeEventArgs_new00_local
static int tolua_CEGUI_CEGUI_TreeEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::TreeEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::TreeEventArgs* tolua_ret = (CEGUI::TreeEventArgs*)  new CEGUI::TreeEventArgs(wnd);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::TreeEventArgs");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: queueID of class  CEGUI::RenderQueueEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__RenderQueueEventArgs_queueID
static int tolua_get_CEGUI__RenderQueueEventArgs_queueID(lua_State* tolua_S)
{
  CEGUI::RenderQueueEventArgs* self = (CEGUI::RenderQueueEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'queueID'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->queueID);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: queueID of class  CEGUI::RenderQueueEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__RenderQueueEventArgs_queueID
static int tolua_set_CEGUI__RenderQueueEventArgs_queueID(lua_State* tolua_S)
{
  CEGUI::RenderQueueEventArgs* self = (CEGUI::RenderQueueEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'queueID'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->queueID = ((CEGUI::RenderQueueID) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::RenderQueueEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderQueueEventArgs_new00
static int tolua_CEGUI_CEGUI_RenderQueueEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::RenderQueueEventArgs",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderQueueID id = ((CEGUI::RenderQueueID) (int)  tolua_tonumber(tolua_S,2,0));
 {
  CEGUI::RenderQueueEventArgs* tolua_ret = (CEGUI::RenderQueueEventArgs*)  new CEGUI::RenderQueueEventArgs(id);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::RenderQueueEventArgs");
 }
 }
 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  CEGUI::RenderQueueEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderQueueEventArgs_new00_local
static int tolua_CEGUI_CEGUI_RenderQueueEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::RenderQueueEventArgs",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderQueueID id = ((CEGUI::RenderQueueID) (int)  tolua_tonumber(tolua_S,2,0));
 {
  CEGUI::RenderQueueEventArgs* tolua_ret = (CEGUI::RenderQueueEventArgs*)  new CEGUI::RenderQueueEventArgs(id);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::RenderQueueEventArgs");
 }
 }
 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: getName of class  CEGUI::Event */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Event_getName00
static int tolua_CEGUI_CEGUI_Event_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Event",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Event* self = (const CEGUI::Event*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: disconnect of class  CEGUI::EventConnection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventConnection_disconnect00
static int tolua_CEGUI_CEGUI_EventConnection_disconnect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::EventConnection",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::EventConnection* self = (CEGUI::EventConnection*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'disconnect'",NULL);
#endif
 {
  self->disconnect();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'disconnect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addEvent of class  CEGUI::EventSet */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventSet_addEvent00
static int tolua_CEGUI_CEGUI_EventSet_addEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::EventSet",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::EventSet* self = (CEGUI::EventSet*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addEvent'",NULL);
#endif
 {
  self->addEvent(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addEvent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeEvent of class  CEGUI::EventSet */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventSet_removeEvent00
static int tolua_CEGUI_CEGUI_EventSet_removeEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::EventSet",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::EventSet* self = (CEGUI::EventSet*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeEvent'",NULL);
#endif
 {
  self->removeEvent(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeEvent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeAllEvents of class  CEGUI::EventSet */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventSet_removeAllEvents00
static int tolua_CEGUI_CEGUI_EventSet_removeAllEvents00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::EventSet",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::EventSet* self = (CEGUI::EventSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeAllEvents'",NULL);
#endif
 {
  self->removeAllEvents();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeAllEvents'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isEventPresent of class  CEGUI::EventSet */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventSet_isEventPresent00
static int tolua_CEGUI_CEGUI_EventSet_isEventPresent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::EventSet",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::EventSet* self = (CEGUI::EventSet*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isEventPresent'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isEventPresent(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isEventPresent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LuaFunctorSubscribeEvent of class  CEGUI::EventSet */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventSet_subscribeEvent00
static int tolua_CEGUI_CEGUI_EventSet_subscribeEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::EventSet",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::EventSet* self = (CEGUI::EventSet*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  lua_Object funcIndex = ((lua_Object)  tolua_tovalue(tolua_S,3,0));
  lua_Object selfIndex = ((lua_Object)  tolua_tovalue(tolua_S,4,LUA_NOREF));
  lua_Object error_handler = ((lua_Object)  tolua_tovalue(tolua_S,5,LUA_NOREF));
  lua_State* tolua_var_1 =  tolua_S;
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LuaFunctorSubscribeEvent'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
   CEGUI::EventConnection tolua_ret = (  CEGUI::EventConnection)  LuaFunctorSubscribeEvent(self,name,funcIndex,selfIndex,error_handler,tolua_var_1);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::EventConnection(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventConnection");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::EventConnection));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventConnection");
#endif
 }
 }
catch(CEGUI::UnknownObjectException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::UnknownObjectException' was thrown by function 'LuaFunctorSubscribeEvent'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'subscribeEvent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: subscribeScriptedEvent of class  CEGUI::EventSet */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventSet_subscribeEvent01
static int tolua_CEGUI_CEGUI_EventSet_subscribeEvent01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::EventSet",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::EventSet* self = (CEGUI::EventSet*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string callback_name = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'subscribeScriptedEvent'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::EventConnection tolua_ret = (CEGUI::EventConnection)  self->subscribeScriptedEvent(name,callback_name);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::EventConnection(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventConnection");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::EventConnection));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventConnection");
#endif
 }
 }
catch(CEGUI::UnknownObjectException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::UnknownObjectException' was thrown by function 'subscribeScriptedEvent'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_EventSet_subscribeEvent00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: fireEvent of class  CEGUI::EventSet */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventSet_fireEvent00
static int tolua_CEGUI_CEGUI_EventSet_fireEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::EventSet",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::EventArgs",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::EventSet* self = (CEGUI::EventSet*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::EventArgs* args = ((CEGUI::EventArgs*)  tolua_tousertype(tolua_S,3,0));
  utf8string eventnamespace = ((utf8string)  tolua_toutf8string(tolua_S,4,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'fireEvent'",NULL);
#endif
 {
  self->fireEvent(name,*args,eventnamespace);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fireEvent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setMutedState of class  CEGUI::EventSet */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventSet_setMutedState00
static int tolua_CEGUI_CEGUI_EventSet_setMutedState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::EventSet",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::EventSet* self = (CEGUI::EventSet*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMutedState'",NULL);
#endif
 {
  self->setMutedState(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMutedState'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ceguiLua_getEventIterator of class  CEGUI::EventSet */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_EventSet_getEventIterator00
static int tolua_CEGUI_CEGUI_EventSet_getEventIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::EventSet",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::EventSet* self = (const CEGUI::EventSet*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ceguiLua_getEventIterator'",NULL);
#endif
 {
  CEGUI::EventIterator tolua_ret = (CEGUI::EventIterator)  ceguiLua_getEventIterator(self);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::EventIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::EventIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEventIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  CEGUI::GlobalEventSet */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GlobalEventSet_getSingleton00
static int tolua_CEGUI_CEGUI_GlobalEventSet_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::GlobalEventSet",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::GlobalEventSet& tolua_ret = (CEGUI::GlobalEventSet&)  CEGUI::GlobalEventSet::getSingleton();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::GlobalEventSet");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_getSingleton00
static int tolua_CEGUI_CEGUI_MouseCursor_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::MouseCursor& tolua_ret = (CEGUI::MouseCursor&)  CEGUI::MouseCursor::getSingleton();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::MouseCursor");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setImage of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_setImage00
static int tolua_CEGUI_CEGUI_MouseCursor_setImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MouseCursor* self = (CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Image* image = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setImage'",NULL);
#endif
 {
  self->setImage(image);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setImage of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_setImage01
static int tolua_CEGUI_CEGUI_MouseCursor_setImage01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::MouseCursor* self = (CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
  utf8string imageset = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string image = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setImage'",NULL);
#endif
 {
  self->setImage(imageset,image);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_MouseCursor_setImage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImage of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_getImage00
static int tolua_CEGUI_CEGUI_MouseCursor_getImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MouseCursor* self = (const CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImage'",NULL);
#endif
 {
  const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getImage();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPosition of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_setPosition00
static int tolua_CEGUI_CEGUI_MouseCursor_setPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MouseCursor* self = (CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* pos = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPosition'",NULL);
#endif
 {
  self->setPosition(*pos);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: offsetPosition of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_offsetPosition00
static int tolua_CEGUI_CEGUI_MouseCursor_offsetPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MouseCursor* self = (CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* offset = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'offsetPosition'",NULL);
#endif
 {
  self->offsetPosition(*offset);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'offsetPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setConstraintArea of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_setConstraintArea00
static int tolua_CEGUI_CEGUI_MouseCursor_setConstraintArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MouseCursor* self = (CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Rect* area = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setConstraintArea'",NULL);
#endif
 {
  self->setConstraintArea(area);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setConstraintArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPosition of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_getPosition00
static int tolua_CEGUI_CEGUI_MouseCursor_getPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MouseCursor* self = (const CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPosition'",NULL);
#endif
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  self->getPosition();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getConstraintArea of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_getConstraintArea00
static int tolua_CEGUI_CEGUI_MouseCursor_getConstraintArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MouseCursor* self = (const CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getConstraintArea'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getConstraintArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getConstraintArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDisplayIndependantPosition of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_getDisplayIndependantPosition00
static int tolua_CEGUI_CEGUI_MouseCursor_getDisplayIndependantPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MouseCursor* self = (const CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDisplayIndependantPosition'",NULL);
#endif
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  self->getDisplayIndependantPosition();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDisplayIndependantPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUnifiedConstraintArea of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_setUnifiedConstraintArea00
static int tolua_CEGUI_CEGUI_MouseCursor_setUnifiedConstraintArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::URect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MouseCursor* self = (CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::URect* area = ((const CEGUI::URect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUnifiedConstraintArea'",NULL);
#endif
 {
  self->setUnifiedConstraintArea(area);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUnifiedConstraintArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUnifiedConstraintArea of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_getUnifiedConstraintArea00
static int tolua_CEGUI_CEGUI_MouseCursor_getUnifiedConstraintArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MouseCursor* self = (const CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUnifiedConstraintArea'",NULL);
#endif
 {
  const CEGUI::URect& tolua_ret = (const CEGUI::URect&)  self->getUnifiedConstraintArea();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::URect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUnifiedConstraintArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hide of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_hide00
static int tolua_CEGUI_CEGUI_MouseCursor_hide00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MouseCursor* self = (CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hide'",NULL);
#endif
 {
  self->hide();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hide'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: show of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_show00
static int tolua_CEGUI_CEGUI_MouseCursor_show00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MouseCursor* self = (CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'show'",NULL);
#endif
 {
  self->show();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'show'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVisible of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_setVisible00
static int tolua_CEGUI_CEGUI_MouseCursor_setVisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MouseCursor* self = (CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
  bool visible = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVisible'",NULL);
#endif
 {
  self->setVisible(visible);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setExplicitRenderSize of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_setExplicitRenderSize00
static int tolua_CEGUI_CEGUI_MouseCursor_setExplicitRenderSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MouseCursor* self = (CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* size = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setExplicitRenderSize'",NULL);
#endif
 {
  self->setExplicitRenderSize(*size);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setExplicitRenderSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getExplicitRenderSize of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_getExplicitRenderSize00
static int tolua_CEGUI_CEGUI_MouseCursor_getExplicitRenderSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MouseCursor* self = (const CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getExplicitRenderSize'",NULL);
#endif
 {
  const CEGUI::Size& tolua_ret = (const CEGUI::Size&)  self->getExplicitRenderSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getExplicitRenderSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ceguiLua_getEventIterator of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_getEventIterator00
static int tolua_CEGUI_CEGUI_MouseCursor_getEventIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MouseCursor",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MouseCursor* self = (const CEGUI::MouseCursor*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ceguiLua_getEventIterator'",NULL);
#endif
 {
  CEGUI::EventIterator tolua_ret = (CEGUI::EventIterator)  ceguiLua_getEventIterator(self);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::EventIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::EventIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEventIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getType of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getType00
static int tolua_CEGUI_CEGUI_Window_getType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getType'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getType();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getName of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getName00
static int tolua_CEGUI_CEGUI_Window_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: rename of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_rename00
static int tolua_CEGUI_CEGUI_Window_rename00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string new_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'rename'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->rename(new_name);
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'rename'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'rename'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: isDisabled of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isDisabled00
static int tolua_CEGUI_CEGUI_Window_isDisabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool localOnly = ((bool)  tolua_toboolean(tolua_S,2,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isDisabled'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isDisabled(localOnly);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isDisabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isVisible of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isVisible00
static int tolua_CEGUI_CEGUI_Window_isVisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool localOnly = ((bool)  tolua_toboolean(tolua_S,2,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isVisible'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isVisible(localOnly);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: setDestroyedByParent of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setDestroyedByParent00
static int tolua_CEGUI_CEGUI_Window_setDestroyedByParent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDestroyedByParent'",NULL);
#endif
 {
  self->setDestroyedByParent(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDestroyedByParent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAlwaysOnTop of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setAlwaysOnTop00
static int tolua_CEGUI_CEGUI_Window_setAlwaysOnTop00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAlwaysOnTop'",NULL);
#endif
 {
  self->setAlwaysOnTop(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAlwaysOnTop'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setEnabled of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setEnabled00
static int tolua_CEGUI_CEGUI_Window_setEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setEnabled'",NULL);
#endif
 {
  self->setEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: enable of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_enable00
static int tolua_CEGUI_CEGUI_Window_enable00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'enable'",NULL);
#endif
 {
  self->enable();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'enable'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: disable of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_disable00
static int tolua_CEGUI_CEGUI_Window_disable00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'disable'",NULL);
#endif
 {
  self->disable();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'disable'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVisible of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setVisible00
static int tolua_CEGUI_CEGUI_Window_setVisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVisible'",NULL);
#endif
 {
  self->setVisible(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: show of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_show00
static int tolua_CEGUI_CEGUI_Window_show00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'show'",NULL);
#endif
 {
  self->show();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'show'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hide of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_hide00
static int tolua_CEGUI_CEGUI_Window_hide00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hide'",NULL);
#endif
 {
  self->hide();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hide'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: activate of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_activate00
static int tolua_CEGUI_CEGUI_Window_activate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'activate'",NULL);
#endif
 {
  self->activate();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'activate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: deactivate of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_deactivate00
static int tolua_CEGUI_CEGUI_Window_deactivate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'deactivate'",NULL);
#endif
 {
  self->deactivate();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'deactivate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setClippedByParent of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setClippedByParent00
static int tolua_CEGUI_CEGUI_Window_setClippedByParent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setClippedByParent'",NULL);
#endif
 {
  self->setClippedByParent(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setClippedByParent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getID of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getID00
static int tolua_CEGUI_CEGUI_Window_getID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getID'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getID();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setID of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setID00
static int tolua_CEGUI_CEGUI_Window_setID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  unsigned int ID = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setID'",NULL);
#endif
 {
  self->setID(ID);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildCount of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getChildCount00
static int tolua_CEGUI_CEGUI_Window_getChildCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getChildCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getChildCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getChildCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isChild of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isChild00
static int tolua_CEGUI_CEGUI_Window_isChild00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  unsigned int ID = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isChild'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isChild(ID);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isChild'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isChild of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isChild01
static int tolua_CEGUI_CEGUI_Window_isChild01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isChild'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isChild(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_isChild00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: isChild of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isChild02
static int tolua_CEGUI_CEGUI_Window_isChild02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isChild'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isChild(window);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_isChild01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: isChildRecursive of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isChildRecursive00
static int tolua_CEGUI_CEGUI_Window_isChildRecursive00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  unsigned int ID = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isChildRecursive'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isChildRecursive(ID);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isChildRecursive'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addChildWindow of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_addChildWindow00
static int tolua_CEGUI_CEGUI_Window_addChildWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addChildWindow'",NULL);
#endif
 {
  self->addChildWindow(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addChildWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addChildWindow of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_addChildWindow01
static int tolua_CEGUI_CEGUI_Window_addChildWindow01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* window = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addChildWindow'",NULL);
#endif
 {
  self->addChildWindow(window);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_addChildWindow00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeChildWindow of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_removeChildWindow00
static int tolua_CEGUI_CEGUI_Window_removeChildWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  unsigned int ID = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeChildWindow'",NULL);
#endif
 {
  self->removeChildWindow(ID);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeChildWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeChildWindow of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_removeChildWindow01
static int tolua_CEGUI_CEGUI_Window_removeChildWindow01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeChildWindow'",NULL);
#endif
 {
  self->removeChildWindow(name);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_removeChildWindow00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeChildWindow of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_removeChildWindow02
static int tolua_CEGUI_CEGUI_Window_removeChildWindow02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* window = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeChildWindow'",NULL);
#endif
 {
  self->removeChildWindow(window);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_removeChildWindow01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChild of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getChild00
static int tolua_CEGUI_CEGUI_Window_getChild00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  unsigned int ID = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getChild'",NULL);
#endif
 try
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getChild(ID);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
catch(CEGUI::UnknownObjectException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getChild'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChild of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getChild01
static int tolua_CEGUI_CEGUI_Window_getChild01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getChild'",NULL);
#endif
 try
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getChild(name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
catch(CEGUI::UnknownObjectException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_getChild00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildRecursive of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getChildRecursive00
static int tolua_CEGUI_CEGUI_Window_getChildRecursive00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  unsigned int ID = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getChildRecursive'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getChildRecursive(ID);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getChildRecursive'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildRecursive of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getChildRecursive01
static int tolua_CEGUI_CEGUI_Window_getChildRecursive01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getChildRecursive'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getChildRecursive(name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_getChildRecursive00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildAtIdx of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getChildAtIdx00
static int tolua_CEGUI_CEGUI_Window_getChildAtIdx00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  unsigned int ID = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getChildAtIdx'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getChildAtIdx(ID);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getChildAtIdx'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildAtPosition of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getChildAtPosition00
static int tolua_CEGUI_CEGUI_Window_getChildAtPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* pos = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getChildAtPosition'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getChildAtPosition(*pos);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getChildAtPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTargetChildAtPosition of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getTargetChildAtPosition00
static int tolua_CEGUI_CEGUI_Window_getTargetChildAtPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* pos = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTargetChildAtPosition'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getTargetChildAtPosition(*pos);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTargetChildAtPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getActiveChild of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getActiveChild00
static int tolua_CEGUI_CEGUI_Window_getActiveChild00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getActiveChild'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getActiveChild();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getActiveChild'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getActiveSibling of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getActiveSibling00
static int tolua_CEGUI_CEGUI_Window_getActiveSibling00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getActiveSibling'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getActiveSibling();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getActiveSibling'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getParent of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getParent00
static int tolua_CEGUI_CEGUI_Window_getParent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getParent'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getParent();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getParent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRootWindow of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getRootWindow00
static int tolua_CEGUI_CEGUI_Window_getRootWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRootWindow'",NULL);
#endif
 {
  const CEGUI::Window* tolua_ret = (const CEGUI::Window*)  self->getRootWindow();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRootWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRootWindow of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getRootWindow01
static int tolua_CEGUI_CEGUI_Window_getRootWindow01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRootWindow'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getRootWindow();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_getRootWindow00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: isAncestor of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isAncestor00
static int tolua_CEGUI_CEGUI_Window_isAncestor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  unsigned int ID = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isAncestor'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isAncestor(ID);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isAncestor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isAncestor of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isAncestor01
static int tolua_CEGUI_CEGUI_Window_isAncestor01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isAncestor'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isAncestor(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_isAncestor00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: isAncestor of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isAncestor02
static int tolua_CEGUI_CEGUI_Window_isAncestor02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isAncestor'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isAncestor(window);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_isAncestor01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFont of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setFont00
static int tolua_CEGUI_CEGUI_Window_setFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFont'",NULL);
#endif
 {
  self->setFont(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFont'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFont of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setFont01
static int tolua_CEGUI_CEGUI_Window_setFont01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Font",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Font* font = ((CEGUI::Font*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFont'",NULL);
#endif
 {
  self->setFont(font);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_setFont00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFont of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getFont00
static int tolua_CEGUI_CEGUI_Window_getFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFont'",NULL);
#endif
 {
  CEGUI::Font* tolua_ret = (CEGUI::Font*)  self->getFont();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Font");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFont'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setText of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setText00
static int tolua_CEGUI_CEGUI_Window_setText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setText'",NULL);
#endif
 {
  self->setText(text);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insertText of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_insertText00
static int tolua_CEGUI_CEGUI_Window_insertText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  unsigned long position = ((unsigned long)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insertText'",NULL);
#endif
 {
  self->insertText(text,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'insertText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: appendText of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_appendText00
static int tolua_CEGUI_CEGUI_Window_appendText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'appendText'",NULL);
#endif
 {
  self->appendText(text);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'appendText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getText of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getText00
static int tolua_CEGUI_CEGUI_Window_getText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getText'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getText();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getAlpha of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getAlpha00
static int tolua_CEGUI_CEGUI_Window_getAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAlpha'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getAlpha();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEffectiveAlpha of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getEffectiveAlpha00
static int tolua_CEGUI_CEGUI_Window_getEffectiveAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEffectiveAlpha'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getEffectiveAlpha();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEffectiveAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAlpha of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setAlpha00
static int tolua_CEGUI_CEGUI_Window_setAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  float a = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAlpha'",NULL);
#endif
 {
  self->setAlpha(a);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setInheritsAlpha of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setInheritsAlpha00
static int tolua_CEGUI_CEGUI_Window_setInheritsAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setInheritsAlpha'",NULL);
#endif
 {
  self->setInheritsAlpha(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setInheritsAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: invalidate of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_invalidate00
static int tolua_CEGUI_CEGUI_Window_invalidate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'invalidate'",NULL);
#endif
 {
  self->invalidate();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'invalidate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setZOrderingEnabled of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setZOrderingEnabled00
static int tolua_CEGUI_CEGUI_Window_setZOrderingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setZOrderingEnabled'",NULL);
#endif
 {
  self->setZOrderingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setZOrderingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUnclippedOuterRect of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getUnclippedOuterRect00
static int tolua_CEGUI_CEGUI_Window_getUnclippedOuterRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUnclippedOuterRect'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getUnclippedOuterRect();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUnclippedOuterRect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUnclippedInnerRect of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getUnclippedInnerRect00
static int tolua_CEGUI_CEGUI_Window_getUnclippedInnerRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUnclippedInnerRect'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getUnclippedInnerRect();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUnclippedInnerRect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUnclippedRect of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getUnclippedRect00
static int tolua_CEGUI_CEGUI_Window_getUnclippedRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool inner = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUnclippedRect'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getUnclippedRect(inner);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUnclippedRect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOuterRectClipper of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getOuterRectClipper00
static int tolua_CEGUI_CEGUI_Window_getOuterRectClipper00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOuterRectClipper'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getOuterRectClipper();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOuterRectClipper'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getInnerRectClipper of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getInnerRectClipper00
static int tolua_CEGUI_CEGUI_Window_getInnerRectClipper00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getInnerRectClipper'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getInnerRectClipper();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInnerRectClipper'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getClipRect of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getClipRect00
static int tolua_CEGUI_CEGUI_Window_getClipRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool non_client = ((bool)  tolua_toboolean(tolua_S,2,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getClipRect'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getClipRect(non_client);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getClipRect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHitTestRect of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getHitTestRect00
static int tolua_CEGUI_CEGUI_Window_getHitTestRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHitTestRect'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getHitTestRect();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHitTestRect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPixelSize of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getPixelSize00
static int tolua_CEGUI_CEGUI_Window_getPixelSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPixelSize'",NULL);
#endif
 {
  CEGUI::Size tolua_ret = (CEGUI::Size)  self->getPixelSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPixelSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getParentPixelSize of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getParentPixelSize00
static int tolua_CEGUI_CEGUI_Window_getParentPixelSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getParentPixelSize'",NULL);
#endif
 {
  CEGUI::Size tolua_ret = (CEGUI::Size)  self->getParentPixelSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getParentPixelSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getParentPixelWidth of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getParentPixelWidth00
static int tolua_CEGUI_CEGUI_Window_getParentPixelWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getParentPixelWidth'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getParentPixelWidth();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getParentPixelWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getParentPixelHeight of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getParentPixelHeight00
static int tolua_CEGUI_CEGUI_Window_getParentPixelHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getParentPixelHeight'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getParentPixelHeight();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getParentPixelHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCaptureWindow of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getCaptureWindow00
static int tolua_CEGUI_CEGUI_Window_getCaptureWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  CEGUI::Window::getCaptureWindow();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCaptureWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRestoreCapture of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setRestoreCapture00
static int tolua_CEGUI_CEGUI_Window_setRestoreCapture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRestoreCapture'",NULL);
#endif
 {
  self->setRestoreCapture(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRestoreCapture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: setDistributesCapturedInputs of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setDistributesCapturedInputs00
static int tolua_CEGUI_CEGUI_Window_setDistributesCapturedInputs00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDistributesCapturedInputs'",NULL);
#endif
 {
  self->setDistributesCapturedInputs(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDistributesCapturedInputs'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: releaseInput of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_releaseInput00
static int tolua_CEGUI_CEGUI_Window_releaseInput00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'releaseInput'",NULL);
#endif
 {
  self->releaseInput();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'releaseInput'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: isHit of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isHit00
static int tolua_CEGUI_CEGUI_Window_isHit00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* pos = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isHit'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isHit(*pos);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isHit'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setRiseOnClickEnabled of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setRiseOnClickEnabled00
static int tolua_CEGUI_CEGUI_Window_setRiseOnClickEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRiseOnClickEnabled'",NULL);
#endif
 {
  self->setRiseOnClickEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRiseOnClickEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMouseCursor of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getMouseCursor00
static int tolua_CEGUI_CEGUI_Window_getMouseCursor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMouseCursor'",NULL);
#endif
 {
  const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getMouseCursor();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMouseCursor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMouseCursor of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setMouseCursor00
static int tolua_CEGUI_CEGUI_Window_setMouseCursor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MouseCursorImage cursor = ((CEGUI::MouseCursorImage) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMouseCursor'",NULL);
#endif
 {
  self->setMouseCursor(cursor);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMouseCursor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMouseCursor of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setMouseCursor01
static int tolua_CEGUI_CEGUI_Window_setMouseCursor01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Image* image = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMouseCursor'",NULL);
#endif
 {
  self->setMouseCursor(image);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_setMouseCursor00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMouseCursor of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setMouseCursor02
static int tolua_CEGUI_CEGUI_Window_setMouseCursor02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string imageset = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string image = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMouseCursor'",NULL);
#endif
 {
  self->setMouseCursor(imageset,image);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_setMouseCursor01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveToFront of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_moveToFront00
static int tolua_CEGUI_CEGUI_Window_moveToFront00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveToFront'",NULL);
#endif
 {
  self->moveToFront();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveToFront'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveToBack of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_moveToBack00
static int tolua_CEGUI_CEGUI_Window_moveToBack00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveToBack'",NULL);
#endif
 {
  self->moveToBack();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveToBack'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveInFront of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_moveInFront00
static int tolua_CEGUI_CEGUI_Window_moveInFront00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveInFront'",NULL);
#endif
 {
  self->moveInFront(window);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveInFront'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveBehind of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_moveBehind00
static int tolua_CEGUI_CEGUI_Window_moveBehind00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveBehind'",NULL);
#endif
 {
  self->moveBehind(window);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveBehind'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: getAutoRepeatDelay of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getAutoRepeatDelay00
static int tolua_CEGUI_CEGUI_Window_getAutoRepeatDelay00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAutoRepeatDelay'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getAutoRepeatDelay();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAutoRepeatDelay'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAutoRepeatRate of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getAutoRepeatRate00
static int tolua_CEGUI_CEGUI_Window_getAutoRepeatRate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAutoRepeatRate'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getAutoRepeatRate();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAutoRepeatRate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setWantsMultiClickEvents of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setWantsMultiClickEvents00
static int tolua_CEGUI_CEGUI_Window_setWantsMultiClickEvents00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWantsMultiClickEvents'",NULL);
#endif
 {
  self->setWantsMultiClickEvents(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWantsMultiClickEvents'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMouseAutoRepeatEnabled of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setMouseAutoRepeatEnabled00
static int tolua_CEGUI_CEGUI_Window_setMouseAutoRepeatEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMouseAutoRepeatEnabled'",NULL);
#endif
 {
  self->setMouseAutoRepeatEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMouseAutoRepeatEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAutoRepeatDelay of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setAutoRepeatDelay00
static int tolua_CEGUI_CEGUI_Window_setAutoRepeatDelay00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  float delay = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoRepeatDelay'",NULL);
#endif
 {
  self->setAutoRepeatDelay(delay);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoRepeatDelay'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAutoRepeatRate of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setAutoRepeatRate00
static int tolua_CEGUI_CEGUI_Window_setAutoRepeatRate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  float rate = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoRepeatRate'",NULL);
#endif
 {
  self->setAutoRepeatRate(rate);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoRepeatRate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getTooltip of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getTooltip00
static int tolua_CEGUI_CEGUI_Window_getTooltip00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTooltip'",NULL);
#endif
 {
  CEGUI::Tooltip* tolua_ret = (CEGUI::Tooltip*)  self->getTooltip();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Tooltip");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTooltip'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTooltipType of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getTooltipType00
static int tolua_CEGUI_CEGUI_Window_getTooltipType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTooltipType'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getTooltipType();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTooltipType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTooltipText of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getTooltipText00
static int tolua_CEGUI_CEGUI_Window_getTooltipText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTooltipText'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getTooltipText();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTooltipText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setTooltip of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setTooltip00
static int tolua_CEGUI_CEGUI_Window_setTooltip00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Tooltip",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Tooltip* tooltip = ((CEGUI::Tooltip*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTooltip'",NULL);
#endif
 {
  self->setTooltip(tooltip);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTooltip'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTooltipType of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setTooltipType00
static int tolua_CEGUI_CEGUI_Window_setTooltipType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string tooltipType = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTooltipType'",NULL);
#endif
 {
  self->setTooltipType(tooltipType);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTooltipType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTooltipText of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setTooltipText00
static int tolua_CEGUI_CEGUI_Window_setTooltipText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string tip = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTooltipText'",NULL);
#endif
 {
  self->setTooltipText(tip);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTooltipText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setInheritsTooltipText of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setInheritsTooltipText00
static int tolua_CEGUI_CEGUI_Window_setInheritsTooltipText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setInheritsTooltipText'",NULL);
#endif
 {
  self->setInheritsTooltipText(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setInheritsTooltipText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: testClassName of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_testClassName00
static int tolua_CEGUI_CEGUI_Window_testClassName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string class_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'testClassName'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->testClassName(class_name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'testClassName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setDragDropTarget of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setDragDropTarget00
static int tolua_CEGUI_CEGUI_Window_setDragDropTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDragDropTarget'",NULL);
#endif
 {
  self->setDragDropTarget(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDragDropTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: notifyDragDropItemEnters of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_notifyDragDropItemEnters00
static int tolua_CEGUI_CEGUI_Window_notifyDragDropItemEnters00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::DragContainer* item = ((CEGUI::DragContainer*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'notifyDragDropItemEnters'",NULL);
#endif
 {
  self->notifyDragDropItemEnters(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'notifyDragDropItemEnters'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: notifyDragDropItemLeaves of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_notifyDragDropItemLeaves00
static int tolua_CEGUI_CEGUI_Window_notifyDragDropItemLeaves00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::DragContainer* item = ((CEGUI::DragContainer*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'notifyDragDropItemLeaves'",NULL);
#endif
 {
  self->notifyDragDropItemLeaves(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'notifyDragDropItemLeaves'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: notifyDragDropItemDropped of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_notifyDragDropItemDropped00
static int tolua_CEGUI_CEGUI_Window_notifyDragDropItemDropped00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::DragContainer* item = ((CEGUI::DragContainer*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'notifyDragDropItemDropped'",NULL);
#endif
 {
  self->notifyDragDropItemDropped(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'notifyDragDropItemDropped'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVerticalAlignment of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getVerticalAlignment00
static int tolua_CEGUI_CEGUI_Window_getVerticalAlignment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVerticalAlignment'",NULL);
#endif
 {
  CEGUI::VerticalAlignment tolua_ret = (CEGUI::VerticalAlignment)  self->getVerticalAlignment();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVerticalAlignment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHorizontalAlignment of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getHorizontalAlignment00
static int tolua_CEGUI_CEGUI_Window_getHorizontalAlignment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHorizontalAlignment'",NULL);
#endif
 {
  CEGUI::HorizontalAlignment tolua_ret = (CEGUI::HorizontalAlignment)  self->getHorizontalAlignment();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorizontalAlignment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVerticalAlignment of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setVerticalAlignment00
static int tolua_CEGUI_CEGUI_Window_setVerticalAlignment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::VerticalAlignment alignment = ((CEGUI::VerticalAlignment) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVerticalAlignment'",NULL);
#endif
 {
  self->setVerticalAlignment(alignment);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVerticalAlignment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHorizontalAlignment of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setHorizontalAlignment00
static int tolua_CEGUI_CEGUI_Window_setHorizontalAlignment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::HorizontalAlignment alignment = ((CEGUI::HorizontalAlignment) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHorizontalAlignment'",NULL);
#endif
 {
  self->setHorizontalAlignment(alignment);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHorizontalAlignment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLookNFeel of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getLookNFeel00
static int tolua_CEGUI_CEGUI_Window_getLookNFeel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLookNFeel'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getLookNFeel();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLookNFeel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setLookNFeel of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setLookNFeel00
static int tolua_CEGUI_CEGUI_Window_setLookNFeel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string lnf = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setLookNFeel'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->setLookNFeel(lnf);
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'setLookNFeel'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setLookNFeel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setWindowRenderer of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setWindowRenderer00
static int tolua_CEGUI_CEGUI_Window_setWindowRenderer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWindowRenderer'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->setWindowRenderer(name);
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'setWindowRenderer'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWindowRenderer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWindowRendererName of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getWindowRendererName00
static int tolua_CEGUI_CEGUI_Window_getWindowRendererName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWindowRendererName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getWindowRendererName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWindowRendererName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setModalState of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setModalState00
static int tolua_CEGUI_CEGUI_Window_setModalState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool state = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setModalState'",NULL);
#endif
 {
  self->setModalState(state);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setModalState'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUserString of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getUserString00
static int tolua_CEGUI_CEGUI_Window_getUserString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUserString'",NULL);
#endif
 try
 {
  string tolua_ret = (string)  self->getUserString(name);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
catch(CEGUI::UnknownObjectException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUserString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isUserStringDefined of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isUserStringDefined00
static int tolua_CEGUI_CEGUI_Window_isUserStringDefined00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isUserStringDefined'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isUserStringDefined(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isUserStringDefined'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUserString of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setUserString00
static int tolua_CEGUI_CEGUI_Window_setUserString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string value = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUserString'",NULL);
#endif
 {
  self->setUserString(name,value);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUserString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: beginInitialisation of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_beginInitialisation00
static int tolua_CEGUI_CEGUI_Window_beginInitialisation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'beginInitialisation'",NULL);
#endif
 {
  self->beginInitialisation();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'beginInitialisation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: endInitialisation of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_endInitialisation00
static int tolua_CEGUI_CEGUI_Window_endInitialisation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'endInitialisation'",NULL);
#endif
 {
  self->endInitialisation();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'endInitialisation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setArea of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setArea00
static int tolua_CEGUI_CEGUI_Window_setArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* xpos = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UDim* ypos = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::UDim* width = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::UDim* height = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setArea'",NULL);
#endif
 {
  self->setArea(*xpos,*ypos,*width,*height);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setArea of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setArea01
static int tolua_CEGUI_CEGUI_Window_setArea01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* pos = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UVector2* size = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setArea'",NULL);
#endif
 {
  self->setArea(*pos,*size);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_setArea00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setArea of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setArea02
static int tolua_CEGUI_CEGUI_Window_setArea02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::URect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::URect* area = ((const CEGUI::URect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setArea'",NULL);
#endif
 {
  self->setArea(*area);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_setArea01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPosition of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setPosition00
static int tolua_CEGUI_CEGUI_Window_setPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* pos = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPosition'",NULL);
#endif
 {
  self->setPosition(*pos);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setXPosition of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setXPosition00
static int tolua_CEGUI_CEGUI_Window_setXPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* x = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setXPosition'",NULL);
#endif
 {
  self->setXPosition(*x);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setXPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setYPosition of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setYPosition00
static int tolua_CEGUI_CEGUI_Window_setYPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* y = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setYPosition'",NULL);
#endif
 {
  self->setYPosition(*y);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setYPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSize of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setSize00
static int tolua_CEGUI_CEGUI_Window_setSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* size = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSize'",NULL);
#endif
 {
  self->setSize(*size);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setWidth of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setWidth00
static int tolua_CEGUI_CEGUI_Window_setWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* width = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWidth'",NULL);
#endif
 {
  self->setWidth(*width);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHeight of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setHeight00
static int tolua_CEGUI_CEGUI_Window_setHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* height = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHeight'",NULL);
#endif
 {
  self->setHeight(*height);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMaxSize of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setMaxSize00
static int tolua_CEGUI_CEGUI_Window_setMaxSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* size = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMaxSize'",NULL);
#endif
 {
  self->setMaxSize(*size);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMaxSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMinSize of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setMinSize00
static int tolua_CEGUI_CEGUI_Window_setMinSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* size = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMinSize'",NULL);
#endif
 {
  self->setMinSize(*size);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMinSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getArea of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getArea00
static int tolua_CEGUI_CEGUI_Window_getArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getArea'",NULL);
#endif
 {
  const CEGUI::URect& tolua_ret = (const CEGUI::URect&)  self->getArea();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::URect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPosition of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getPosition00
static int tolua_CEGUI_CEGUI_Window_getPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPosition'",NULL);
#endif
 {
  const CEGUI::UVector2& tolua_ret = (const CEGUI::UVector2&)  self->getPosition();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::UVector2");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getXPosition of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getXPosition00
static int tolua_CEGUI_CEGUI_Window_getXPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getXPosition'",NULL);
#endif
 {
  const CEGUI::UDim& tolua_ret = (const CEGUI::UDim&)  self->getXPosition();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::UDim");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getXPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getYPosition of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getYPosition00
static int tolua_CEGUI_CEGUI_Window_getYPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getYPosition'",NULL);
#endif
 {
  const CEGUI::UDim& tolua_ret = (const CEGUI::UDim&)  self->getYPosition();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::UDim");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getYPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSize of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getSize00
static int tolua_CEGUI_CEGUI_Window_getSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSize'",NULL);
#endif
 {
  CEGUI::UVector2 tolua_ret = (CEGUI::UVector2)  self->getSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UVector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UVector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#endif
 }
 }
 }
 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: getWidth of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getWidth00
static int tolua_CEGUI_CEGUI_Window_getWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWidth'",NULL);
#endif
 {
  CEGUI::UDim tolua_ret = (CEGUI::UDim)  self->getWidth();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UDim(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UDim));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHeight of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getHeight00
static int tolua_CEGUI_CEGUI_Window_getHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHeight'",NULL);
#endif
 {
  CEGUI::UDim tolua_ret = (CEGUI::UDim)  self->getHeight();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UDim(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UDim));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMaxSize of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getMaxSize00
static int tolua_CEGUI_CEGUI_Window_getMaxSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMaxSize'",NULL);
#endif
 {
  const CEGUI::UVector2& tolua_ret = (const CEGUI::UVector2&)  self->getMaxSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::UVector2");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMaxSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMinSize of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getMinSize00
static int tolua_CEGUI_CEGUI_Window_getMinSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMinSize'",NULL);
#endif
 {
  const CEGUI::UVector2& tolua_ret = (const CEGUI::UVector2&)  self->getMinSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::UVector2");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMinSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setMousePassThroughEnabled of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setMousePassThroughEnabled00
static int tolua_CEGUI_CEGUI_Window_setMousePassThroughEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMousePassThroughEnabled'",NULL);
#endif
 {
  self->setMousePassThroughEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMousePassThroughEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setWritingXMLAllowed of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setWritingXMLAllowed00
static int tolua_CEGUI_CEGUI_Window_setWritingXMLAllowed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool allow = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWritingXMLAllowed'",NULL);
#endif
 {
  self->setWritingXMLAllowed(allow);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWritingXMLAllowed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRotation of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getRotation00
static int tolua_CEGUI_CEGUI_Window_getRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRotation'",NULL);
#endif
 {
  const CEGUI::Vector3& tolua_ret = (const CEGUI::Vector3&)  self->getRotation();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector3");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRotation of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setRotation00
static int tolua_CEGUI_CEGUI_Window_setRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector3* rotation = ((const CEGUI::Vector3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRotation'",NULL);
#endif
 {
  self->setRotation(*rotation);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTargetRenderingSurface of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getTargetRenderingSurface00
static int tolua_CEGUI_CEGUI_Window_getTargetRenderingSurface00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTargetRenderingSurface'",NULL);
#endif
 {
  CEGUI::RenderingSurface& tolua_ret = (CEGUI::RenderingSurface&)  self->getTargetRenderingSurface();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::RenderingSurface");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTargetRenderingSurface'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRenderingContext of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getRenderingContext00
static int tolua_CEGUI_CEGUI_Window_getRenderingContext00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::RenderingContext",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::RenderingContext* ctx = ((CEGUI::RenderingContext*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRenderingContext'",NULL);
#endif
 {
  self->getRenderingContext(*ctx);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRenderingContext'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRenderingSurface of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getRenderingSurface00
static int tolua_CEGUI_CEGUI_Window_getRenderingSurface00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRenderingSurface'",NULL);
#endif
 {
  CEGUI::RenderingSurface* tolua_ret = (CEGUI::RenderingSurface*)  self->getRenderingSurface();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::RenderingSurface");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRenderingSurface'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRenderingSurface of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setRenderingSurface00
static int tolua_CEGUI_CEGUI_Window_setRenderingSurface00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::RenderingSurface",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::RenderingSurface* surface = ((CEGUI::RenderingSurface*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRenderingSurface'",NULL);
#endif
 {
  self->setRenderingSurface(surface);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRenderingSurface'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setUsingAutoRenderingSurface of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setUsingAutoRenderingSurface00
static int tolua_CEGUI_CEGUI_Window_setUsingAutoRenderingSurface00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUsingAutoRenderingSurface'",NULL);
#endif
 {
  self->setUsingAutoRenderingSurface(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUsingAutoRenderingSurface'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: invalidateRenderingSurface of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_invalidateRenderingSurface00
static int tolua_CEGUI_CEGUI_Window_invalidateRenderingSurface00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'invalidateRenderingSurface'",NULL);
#endif
 {
  self->invalidateRenderingSurface();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'invalidateRenderingSurface'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setNonClientWindow of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setNonClientWindow00
static int tolua_CEGUI_CEGUI_Window_setNonClientWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const bool setting = ((const bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNonClientWindow'",NULL);
#endif
 {
  self->setNonClientWindow(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNonClientWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getGeometryBuffer of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getGeometryBuffer00
static int tolua_CEGUI_CEGUI_Window_getGeometryBuffer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getGeometryBuffer'",NULL);
#endif
 {
  CEGUI::GeometryBuffer& tolua_ret = (CEGUI::GeometryBuffer&)  self->getGeometryBuffer();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::GeometryBuffer");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getGeometryBuffer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setTextParsingEnabled of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setTextParsingEnabled00
static int tolua_CEGUI_CEGUI_Window_setTextParsingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTextParsingEnabled'",NULL);
#endif
 {
  self->setTextParsingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTextParsingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUnprojectedPosition of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getUnprojectedPosition00
static int tolua_CEGUI_CEGUI_Window_getUnprojectedPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* pos = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUnprojectedPosition'",NULL);
#endif
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  self->getUnprojectedPosition(*pos);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUnprojectedPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: banPropertyFromXML of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_banPropertyFromXML00
static int tolua_CEGUI_CEGUI_Window_banPropertyFromXML00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string property_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'banPropertyFromXML'",NULL);
#endif
 {
  self->banPropertyFromXML(property_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'banPropertyFromXML'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: unbanPropertyFromXML of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_unbanPropertyFromXML00
static int tolua_CEGUI_CEGUI_Window_unbanPropertyFromXML00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string property_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unbanPropertyFromXML'",NULL);
#endif
 {
  self->unbanPropertyFromXML(property_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'unbanPropertyFromXML'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isPropertyBannedFromXML of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isPropertyBannedFromXML00
static int tolua_CEGUI_CEGUI_Window_isPropertyBannedFromXML00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string property_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isPropertyBannedFromXML'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isPropertyBannedFromXML(property_name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isPropertyBannedFromXML'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUpdateMode of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setUpdateMode00
static int tolua_CEGUI_CEGUI_Window_setUpdateMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::WindowUpdateMode mode = ((CEGUI::WindowUpdateMode) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUpdateMode'",NULL);
#endif
 {
  self->setUpdateMode(mode);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUpdateMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUpdateMode of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getUpdateMode00
static int tolua_CEGUI_CEGUI_Window_getUpdateMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUpdateMode'",NULL);
#endif
 {
  CEGUI::WindowUpdateMode tolua_ret = (CEGUI::WindowUpdateMode)  self->getUpdateMode();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUpdateMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMouseInputPropagationEnabled of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setMouseInputPropagationEnabled00
static int tolua_CEGUI_CEGUI_Window_setMouseInputPropagationEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMouseInputPropagationEnabled'",NULL);
#endif
 {
  self->setMouseInputPropagationEnabled(enabled);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMouseInputPropagationEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: clone of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_clone00
static int tolua_CEGUI_CEGUI_Window_clone00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string newName = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  bool deepCopy = ((bool)  tolua_toboolean(tolua_S,3,true));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clone'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->clone(newName,deepCopy);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clone'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getZIndex of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getZIndex00
static int tolua_CEGUI_CEGUI_Window_getZIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getZIndex'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getZIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getZIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isInFront of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isInFront00
static int tolua_CEGUI_CEGUI_Window_isInFront00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* wnd = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isInFront'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isInFront(*wnd);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isInFront'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isBehind of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isBehind00
static int tolua_CEGUI_CEGUI_Window_isBehind00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* wnd = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isBehind'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isBehind(*wnd);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isBehind'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setProperty of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setProperty00
static int tolua_CEGUI_CEGUI_Window_setProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string value = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setProperty'",NULL);
#endif
 {
  self->setProperty(name,value);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setProperty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getProperty of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getProperty00
static int tolua_CEGUI_CEGUI_Window_getProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getProperty'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getProperty(name);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getProperty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPropertyDefault of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getPropertyDefault00
static int tolua_CEGUI_CEGUI_Window_getPropertyDefault00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPropertyDefault'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getPropertyDefault(name);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPropertyDefault'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPropertyHelp of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getPropertyHelp00
static int tolua_CEGUI_CEGUI_Window_getPropertyHelp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPropertyHelp'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getPropertyHelp(name);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPropertyHelp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isPropertyPresent of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isPropertyPresent00
static int tolua_CEGUI_CEGUI_Window_isPropertyPresent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isPropertyPresent'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isPropertyPresent(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isPropertyPresent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isPropertyDefault of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isPropertyDefault00
static int tolua_CEGUI_CEGUI_Window_isPropertyDefault00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isPropertyDefault'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isPropertyDefault(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isPropertyDefault'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ceguiLua_getPropertyIterator of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getPropertyIterator00
static int tolua_CEGUI_CEGUI_Window_getPropertyIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ceguiLua_getPropertyIterator'",NULL);
#endif
 {
  CEGUI::PropertyIterator tolua_ret = (CEGUI::PropertyIterator)  ceguiLua_getPropertyIterator(self);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::PropertyIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::PropertyIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::PropertyIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::PropertyIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPropertyIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addEvent of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_addEvent00
static int tolua_CEGUI_CEGUI_Window_addEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addEvent'",NULL);
#endif
 {
  self->addEvent(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addEvent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeEvent of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_removeEvent00
static int tolua_CEGUI_CEGUI_Window_removeEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeEvent'",NULL);
#endif
 {
  self->removeEvent(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeEvent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeAllEvents of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_removeAllEvents00
static int tolua_CEGUI_CEGUI_Window_removeAllEvents00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeAllEvents'",NULL);
#endif
 {
  self->removeAllEvents();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeAllEvents'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isEventPresent of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isEventPresent00
static int tolua_CEGUI_CEGUI_Window_isEventPresent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isEventPresent'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isEventPresent(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isEventPresent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LuaFunctorSubscribeEvent of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_subscribeEvent00
static int tolua_CEGUI_CEGUI_Window_subscribeEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  lua_Object funcIndex = ((lua_Object)  tolua_tovalue(tolua_S,3,0));
  lua_Object selfIndex = ((lua_Object)  tolua_tovalue(tolua_S,4,LUA_NOREF));
  lua_Object error_handler = ((lua_Object)  tolua_tovalue(tolua_S,5,LUA_NOREF));
  lua_State* tolua_var_2 =  tolua_S;
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LuaFunctorSubscribeEvent'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
   CEGUI::EventConnection tolua_ret = (  CEGUI::EventConnection)  LuaFunctorSubscribeEvent(self,name,funcIndex,selfIndex,error_handler,tolua_var_2);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::EventConnection(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventConnection");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::EventConnection));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventConnection");
#endif
 }
 }
catch(CEGUI::UnknownObjectException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::UnknownObjectException' was thrown by function 'LuaFunctorSubscribeEvent'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'subscribeEvent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: subscribeScriptedEvent of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_subscribeEvent01
static int tolua_CEGUI_CEGUI_Window_subscribeEvent01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string callback_name = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'subscribeScriptedEvent'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::EventConnection tolua_ret = (CEGUI::EventConnection)  self->subscribeScriptedEvent(name,callback_name);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::EventConnection(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventConnection");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::EventConnection));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventConnection");
#endif
 }
 }
catch(CEGUI::UnknownObjectException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::UnknownObjectException' was thrown by function 'subscribeScriptedEvent'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_subscribeEvent00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: fireEvent of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_fireEvent00
static int tolua_CEGUI_CEGUI_Window_fireEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::EventArgs",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::EventArgs* args = ((CEGUI::EventArgs*)  tolua_tousertype(tolua_S,3,0));
  utf8string eventnamespace = ((utf8string)  tolua_toutf8string(tolua_S,4,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'fireEvent'",NULL);
#endif
 {
  self->fireEvent(name,*args,eventnamespace);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fireEvent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setMutedState of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setMutedState00
static int tolua_CEGUI_CEGUI_Window_setMutedState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMutedState'",NULL);
#endif
 {
  self->setMutedState(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMutedState'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ceguiLua_getEventIterator of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getEventIterator00
static int tolua_CEGUI_CEGUI_Window_getEventIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* self = (const CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ceguiLua_getEventIterator'",NULL);
#endif
 {
  CEGUI::EventIterator tolua_ret = (CEGUI::EventIterator)  ceguiLua_getEventIterator(self);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::EventIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::EventIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEventIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: windowToScreenX of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_windowToScreenX00
static int tolua_CEGUI_CEGUI_CoordConverter_windowToScreenX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UDim* x = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
 {
  float tolua_ret = (float)  CEGUI::CoordConverter::windowToScreenX(*window,*x);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'windowToScreenX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: windowToScreenX of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_windowToScreenX01
static int tolua_CEGUI_CEGUI_CoordConverter_windowToScreenX01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const float x = ((const float)  tolua_tonumber(tolua_S,3,0));
 {
  float tolua_ret = (float)  CEGUI::CoordConverter::windowToScreenX(*window,x);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_windowToScreenX00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: windowToScreenY of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_windowToScreenY00
static int tolua_CEGUI_CEGUI_CoordConverter_windowToScreenY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UDim* y = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
 {
  float tolua_ret = (float)  CEGUI::CoordConverter::windowToScreenY(*window,*y);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'windowToScreenY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: windowToScreenY of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_windowToScreenY01
static int tolua_CEGUI_CEGUI_CoordConverter_windowToScreenY01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const float y = ((const float)  tolua_tonumber(tolua_S,3,0));
 {
  float tolua_ret = (float)  CEGUI::CoordConverter::windowToScreenY(*window,y);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_windowToScreenY00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: windowToScreen of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_windowToScreen00
static int tolua_CEGUI_CEGUI_CoordConverter_windowToScreen00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UVector2* vec = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  CEGUI::CoordConverter::windowToScreen(*window,*vec);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'windowToScreen'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: windowToScreen of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_windowToScreen01
static int tolua_CEGUI_CEGUI_CoordConverter_windowToScreen01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Vector2* vec = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  CEGUI::CoordConverter::windowToScreen(*window,*vec);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_windowToScreen00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: windowToScreen of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_windowToScreen02
static int tolua_CEGUI_CEGUI_CoordConverter_windowToScreen02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::URect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::URect* rect = ((const CEGUI::URect*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  CEGUI::CoordConverter::windowToScreen(*window,*rect);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_windowToScreen01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: windowToScreen of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_windowToScreen03
static int tolua_CEGUI_CEGUI_CoordConverter_windowToScreen03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Rect* rect = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  CEGUI::CoordConverter::windowToScreen(*window,*rect);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_windowToScreen02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: screenToWindowX of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_screenToWindowX00
static int tolua_CEGUI_CEGUI_CoordConverter_screenToWindowX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UDim* x = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
 {
  float tolua_ret = (float)  CEGUI::CoordConverter::screenToWindowX(*window,*x);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'screenToWindowX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: screenToWindowX of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_screenToWindowX01
static int tolua_CEGUI_CEGUI_CoordConverter_screenToWindowX01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const float x = ((const float)  tolua_tonumber(tolua_S,3,0));
 {
  float tolua_ret = (float)  CEGUI::CoordConverter::screenToWindowX(*window,x);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_screenToWindowX00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: screenToWindowY of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_screenToWindowY00
static int tolua_CEGUI_CEGUI_CoordConverter_screenToWindowY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UDim* y = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
 {
  float tolua_ret = (float)  CEGUI::CoordConverter::screenToWindowY(*window,*y);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'screenToWindowY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: screenToWindowY of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_screenToWindowY01
static int tolua_CEGUI_CEGUI_CoordConverter_screenToWindowY01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const float y = ((const float)  tolua_tonumber(tolua_S,3,0));
 {
  float tolua_ret = (float)  CEGUI::CoordConverter::screenToWindowY(*window,y);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_screenToWindowY00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: screenToWindow of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_screenToWindow00
static int tolua_CEGUI_CEGUI_CoordConverter_screenToWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UVector2* vec = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  CEGUI::CoordConverter::screenToWindow(*window,*vec);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'screenToWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: screenToWindow of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_screenToWindow01
static int tolua_CEGUI_CEGUI_CoordConverter_screenToWindow01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Vector2* vec = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  CEGUI::CoordConverter::screenToWindow(*window,*vec);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_screenToWindow00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: screenToWindow of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_screenToWindow02
static int tolua_CEGUI_CEGUI_CoordConverter_screenToWindow02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::URect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::URect* rect = ((const CEGUI::URect*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  CEGUI::CoordConverter::screenToWindow(*window,*rect);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_screenToWindow01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: screenToWindow of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_screenToWindow03
static int tolua_CEGUI_CEGUI_CoordConverter_screenToWindow03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::CoordConverter",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Rect* rect = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  CEGUI::CoordConverter::screenToWindow(*window,*rect);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_screenToWindow02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getSingleton00
static int tolua_CEGUI_CEGUI_System_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::System& tolua_ret = (CEGUI::System&)  CEGUI::System::getSingleton();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::System");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRenderer of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getRenderer00
static int tolua_CEGUI_CEGUI_System_getRenderer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRenderer'",NULL);
#endif
 {
  CEGUI::Renderer* tolua_ret = (CEGUI::Renderer*)  self->getRenderer();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Renderer");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRenderer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDefaultFont of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_setDefaultFont00
static int tolua_CEGUI_CEGUI_System_setDefaultFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDefaultFont'",NULL);
#endif
 {
  self->setDefaultFont(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDefaultFont'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDefaultFont of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_setDefaultFont01
static int tolua_CEGUI_CEGUI_System_setDefaultFont01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Font",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Font* font = ((CEGUI::Font*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDefaultFont'",NULL);
#endif
 {
  self->setDefaultFont(font);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_System_setDefaultFont00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultFont of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getDefaultFont00
static int tolua_CEGUI_CEGUI_System_getDefaultFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDefaultFont'",NULL);
#endif
 {
  CEGUI::Font* tolua_ret = (CEGUI::Font*)  self->getDefaultFont();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Font");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultFont'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: signalRedraw of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_signalRedraw00
static int tolua_CEGUI_CEGUI_System_signalRedraw00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'signalRedraw'",NULL);
#endif
 {
  self->signalRedraw();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'signalRedraw'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: renderGUI of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_renderGUI00
static int tolua_CEGUI_CEGUI_System_renderGUI00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'renderGUI'",NULL);
#endif
 {
  self->renderGUI();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'renderGUI'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setGUISheet of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_setGUISheet00
static int tolua_CEGUI_CEGUI_System_setGUISheet00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* sheet = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setGUISheet'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->setGUISheet(sheet);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setGUISheet'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getGUISheet of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getGUISheet00
static int tolua_CEGUI_CEGUI_System_getGUISheet00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getGUISheet'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getGUISheet();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getGUISheet'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSingleClickTimeout of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_setSingleClickTimeout00
static int tolua_CEGUI_CEGUI_System_setSingleClickTimeout00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  double timeout = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSingleClickTimeout'",NULL);
#endif
 {
  self->setSingleClickTimeout(timeout);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSingleClickTimeout'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMultiClickTimeout of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_setMultiClickTimeout00
static int tolua_CEGUI_CEGUI_System_setMultiClickTimeout00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  double timeout = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMultiClickTimeout'",NULL);
#endif
 {
  self->setMultiClickTimeout(timeout);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMultiClickTimeout'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMultiClickToleranceAreaSize of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_setMultiClickToleranceAreaSize00
static int tolua_CEGUI_CEGUI_System_setMultiClickToleranceAreaSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* sz = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMultiClickToleranceAreaSize'",NULL);
#endif
 {
  self->setMultiClickToleranceAreaSize(*sz);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMultiClickToleranceAreaSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleClickTimeout of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getSingleClickTimeout00
static int tolua_CEGUI_CEGUI_System_getSingleClickTimeout00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSingleClickTimeout'",NULL);
#endif
 {
  double tolua_ret = (double)  self->getSingleClickTimeout();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleClickTimeout'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMultiClickTimeout of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getMultiClickTimeout00
static int tolua_CEGUI_CEGUI_System_getMultiClickTimeout00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMultiClickTimeout'",NULL);
#endif
 {
  double tolua_ret = (double)  self->getMultiClickTimeout();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMultiClickTimeout'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMultiClickToleranceAreaSize of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getMultiClickToleranceAreaSize00
static int tolua_CEGUI_CEGUI_System_getMultiClickToleranceAreaSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMultiClickToleranceAreaSize'",NULL);
#endif
 {
  const CEGUI::Size& tolua_ret = (const CEGUI::Size&)  self->getMultiClickToleranceAreaSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMultiClickToleranceAreaSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setMouseClickEventGenerationEnabled of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_setMouseClickEventGenerationEnabled00
static int tolua_CEGUI_CEGUI_System_setMouseClickEventGenerationEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  bool enable = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMouseClickEventGenerationEnabled'",NULL);
#endif
 {
  self->setMouseClickEventGenerationEnabled(enable);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMouseClickEventGenerationEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDefaultMouseCursor of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_setDefaultMouseCursor00
static int tolua_CEGUI_CEGUI_System_setDefaultMouseCursor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MouseCursorImage image = ((CEGUI::MouseCursorImage) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDefaultMouseCursor'",NULL);
#endif
 {
  self->setDefaultMouseCursor(image);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDefaultMouseCursor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDefaultMouseCursor of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_setDefaultMouseCursor01
static int tolua_CEGUI_CEGUI_System_setDefaultMouseCursor01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Image* image = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDefaultMouseCursor'",NULL);
#endif
 {
  self->setDefaultMouseCursor(image);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_System_setDefaultMouseCursor00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDefaultMouseCursor of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_setDefaultMouseCursor02
static int tolua_CEGUI_CEGUI_System_setDefaultMouseCursor02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  utf8string imageset_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string image_name = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDefaultMouseCursor'",NULL);
#endif
 {
  self->setDefaultMouseCursor(imageset_name,image_name);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_System_setDefaultMouseCursor01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultMouseCursor of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getDefaultMouseCursor00
static int tolua_CEGUI_CEGUI_System_getDefaultMouseCursor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDefaultMouseCursor'",NULL);
#endif
 {
  const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getDefaultMouseCursor();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultMouseCursor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWindowContainingMouse of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getWindowContainingMouse00
static int tolua_CEGUI_CEGUI_System_getWindowContainingMouse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWindowContainingMouse'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getWindowContainingMouse();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWindowContainingMouse'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: executeScriptFile of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_executeScriptFile00
static int tolua_CEGUI_CEGUI_System_executeScriptFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  utf8string filename = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'executeScriptFile'",NULL);
#endif
 {
  self->executeScriptFile(filename);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'executeScriptFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: executeScriptGlobal of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_executeScriptGlobal00
static int tolua_CEGUI_CEGUI_System_executeScriptGlobal00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  utf8string global_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'executeScriptGlobal'",NULL);
#endif
 {
  int tolua_ret = (int)  self->executeScriptGlobal(global_name);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'executeScriptGlobal'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: executeScriptString of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_executeScriptString00
static int tolua_CEGUI_CEGUI_System_executeScriptString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  utf8string lua_string = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'executeScriptString'",NULL);
#endif
 {
  self->executeScriptString(lua_string);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'executeScriptString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMouseMoveScaling of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getMouseMoveScaling00
static int tolua_CEGUI_CEGUI_System_getMouseMoveScaling00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMouseMoveScaling'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getMouseMoveScaling();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMouseMoveScaling'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMouseMoveScaling of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_setMouseMoveScaling00
static int tolua_CEGUI_CEGUI_System_setMouseMoveScaling00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  float scaling = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMouseMoveScaling'",NULL);
#endif
 {
  self->setMouseMoveScaling(scaling);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMouseMoveScaling'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: notifyWindowDestroyed of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_notifyWindowDestroyed00
static int tolua_CEGUI_CEGUI_System_notifyWindowDestroyed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'notifyWindowDestroyed'",NULL);
#endif
 {
  self->notifyWindowDestroyed(window);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'notifyWindowDestroyed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ceguiLua_System_isSystemKeyDown of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_isSystemKeyDown00
static int tolua_CEGUI_CEGUI_System_isSystemKeyDown00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::SystemKey k = ((CEGUI::SystemKey) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ceguiLua_System_isSystemKeyDown'",NULL);
#endif
 {
  bool tolua_ret = (bool)  ceguiLua_System_isSystemKeyDown(self,k);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isSystemKeyDown'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDefaultTooltip of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_setDefaultTooltip00
static int tolua_CEGUI_CEGUI_System_setDefaultTooltip00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Tooltip",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Tooltip* tooltip = ((CEGUI::Tooltip*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDefaultTooltip'",NULL);
#endif
 {
  self->setDefaultTooltip(tooltip);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDefaultTooltip'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDefaultTooltip of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_setDefaultTooltip01
static int tolua_CEGUI_CEGUI_System_setDefaultTooltip01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  utf8string tooltipType = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDefaultTooltip'",NULL);
#endif
 {
  self->setDefaultTooltip(tooltipType);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_System_setDefaultTooltip00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultTooltip of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getDefaultTooltip00
static int tolua_CEGUI_CEGUI_System_getDefaultTooltip00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDefaultTooltip'",NULL);
#endif
 {
  CEGUI::Tooltip* tolua_ret = (CEGUI::Tooltip*)  self->getDefaultTooltip();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Tooltip");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultTooltip'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: notifyDisplaySizeChanged of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_notifyDisplaySizeChanged00
static int tolua_CEGUI_CEGUI_System_notifyDisplaySizeChanged00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* new_size = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'notifyDisplaySizeChanged'",NULL);
#endif
 {
  self->notifyDisplaySizeChanged(*new_size);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'notifyDisplaySizeChanged'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectMouseMove of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_injectMouseMove00
static int tolua_CEGUI_CEGUI_System_injectMouseMove00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  float dx = ((float)  tolua_tonumber(tolua_S,2,0));
  float dy = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMouseMove'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectMouseMove(dx,dy);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectMouseMove'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: injectMouseButtonDown of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_injectMouseButtonDown00
static int tolua_CEGUI_CEGUI_System_injectMouseButtonDown00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MouseButton btn = ((CEGUI::MouseButton) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMouseButtonDown'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectMouseButtonDown(btn);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectMouseButtonDown'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectMouseButtonUp of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_injectMouseButtonUp00
static int tolua_CEGUI_CEGUI_System_injectMouseButtonUp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MouseButton btn = ((CEGUI::MouseButton) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMouseButtonUp'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectMouseButtonUp(btn);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectMouseButtonUp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectKeyDown of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_injectKeyDown00
static int tolua_CEGUI_CEGUI_System_injectKeyDown00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  unsigned int keycode = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectKeyDown'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectKeyDown(keycode);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectKeyDown'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectKeyUp of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_injectKeyUp00
static int tolua_CEGUI_CEGUI_System_injectKeyUp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  unsigned int keycode = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectKeyUp'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectKeyUp(keycode);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectKeyUp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectChar of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_injectChar00
static int tolua_CEGUI_CEGUI_System_injectChar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  unsigned long code_point = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectChar'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectChar(code_point);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectChar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectMouseWheelChange of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_injectMouseWheelChange00
static int tolua_CEGUI_CEGUI_System_injectMouseWheelChange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  float delta = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMouseWheelChange'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectMouseWheelChange(delta);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectMouseWheelChange'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectMousePosition of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_injectMousePosition00
static int tolua_CEGUI_CEGUI_System_injectMousePosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  float x = ((float)  tolua_tonumber(tolua_S,2,0));
  float y = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMousePosition'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectMousePosition(x,y);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectMousePosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectTimePulse of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_injectTimePulse00
static int tolua_CEGUI_CEGUI_System_injectTimePulse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  float timeElapsed = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectTimePulse'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectTimePulse(timeElapsed);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectTimePulse'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectMouseButtonClick of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_injectMouseButtonClick00
static int tolua_CEGUI_CEGUI_System_injectMouseButtonClick00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MouseButton btn = ((CEGUI::MouseButton) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMouseButtonClick'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectMouseButtonClick(btn);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectMouseButtonClick'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectMouseButtonDoubleClick of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_injectMouseButtonDoubleClick00
static int tolua_CEGUI_CEGUI_System_injectMouseButtonDoubleClick00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MouseButton btn = ((CEGUI::MouseButton) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMouseButtonDoubleClick'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectMouseButtonDoubleClick(btn);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectMouseButtonDoubleClick'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectMouseButtonTripleClick of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_injectMouseButtonTripleClick00
static int tolua_CEGUI_CEGUI_System_injectMouseButtonTripleClick00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::System",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::System* self = (CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MouseButton btn = ((CEGUI::MouseButton) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMouseButtonTripleClick'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectMouseButtonTripleClick(btn);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectMouseButtonTripleClick'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ceguiLua_getEventIterator of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getEventIterator00
static int tolua_CEGUI_CEGUI_System_getEventIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::System",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::System* self = (const CEGUI::System*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ceguiLua_getEventIterator'",NULL);
#endif
 {
  CEGUI::EventIterator tolua_ret = (CEGUI::EventIterator)  ceguiLua_getEventIterator(self);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::EventIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::EventIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEventIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_getSingleton00
static int tolua_CEGUI_CEGUI_WindowManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::WindowManager& tolua_ret = (CEGUI::WindowManager&)  CEGUI::WindowManager::getSingleton();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::WindowManager");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createWindow of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_createWindow00
static int tolua_CEGUI_CEGUI_WindowManager_createWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowManager* self = (CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string type = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,3,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createWindow'",NULL);
#endif
 try
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->createWindow(type,name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
catch(CEGUI::AlreadyExistsException CEGUIDeadException(&e))
{
 return 0;
}
 catch(CEGUI::InvalidRequestException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: loadWindowLayout of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_loadWindowLayout00
static int tolua_CEGUI_CEGUI_WindowManager_loadWindowLayout00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,1,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowManager* self = (CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string filename = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string name_prefix = ((utf8string)  tolua_toutf8string(tolua_S,3,""));
  utf8string resourcegroup = ((utf8string)  tolua_toutf8string(tolua_S,4,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadWindowLayout'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->loadWindowLayout(filename,name_prefix,resourcegroup);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'loadWindowLayout'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 catch(std::exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'std::exception' was thrown by function 'loadWindowLayout'\nMessage: %s",e.what());
 errorDoIt = true;
}
 catch(...)
{
 snprintf(errorBuffer,512,"Unknown exception thrown by function 'loadWindowLayout'");
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadWindowLayout'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeWindowLayoutToStream of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_writeWindowLayoutToStream00
static int tolua_CEGUI_CEGUI_WindowManager_writeWindowLayoutToStream00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::OutStream",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowManager* self = (const CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string window = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::OutStream* out = ((CEGUI::OutStream*)  tolua_tousertype(tolua_S,3,0));
  bool writeParent = ((bool)  tolua_toboolean(tolua_S,4,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeWindowLayoutToStream'",NULL);
#endif
 {
  self->writeWindowLayoutToStream(window,*out,writeParent);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeWindowLayoutToStream'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeWindowLayoutToStream of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_writeWindowLayoutToStream01
static int tolua_CEGUI_CEGUI_WindowManager_writeWindowLayoutToStream01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::OutStream",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::WindowManager* self = (const CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::OutStream* out = ((CEGUI::OutStream*)  tolua_tousertype(tolua_S,3,0));
  bool writeParent = ((bool)  tolua_toboolean(tolua_S,4,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeWindowLayoutToStream'",NULL);
#endif
 {
  self->writeWindowLayoutToStream(*window,*out,writeParent);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_WindowManager_writeWindowLayoutToStream00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: saveWindowLayout of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_saveWindowLayout00
static int tolua_CEGUI_CEGUI_WindowManager_saveWindowLayout00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowManager* self = (const CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string window = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string filename = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  bool writeParent = ((bool)  tolua_toboolean(tolua_S,4,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'saveWindowLayout'",NULL);
#endif
 {
  self->saveWindowLayout(window,filename,writeParent);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'saveWindowLayout'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: saveWindowLayout of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_saveWindowLayout01
static int tolua_CEGUI_CEGUI_WindowManager_saveWindowLayout01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::WindowManager* self = (const CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* window = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  utf8string filename = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  bool writeParent = ((bool)  tolua_toboolean(tolua_S,4,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'saveWindowLayout'",NULL);
#endif
 {
  self->saveWindowLayout(*window,filename,writeParent);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_WindowManager_saveWindowLayout00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyWindow of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_destroyWindow00
static int tolua_CEGUI_CEGUI_WindowManager_destroyWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowManager* self = (CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyWindow'",NULL);
#endif
 {
  self->destroyWindow(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyWindow of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_destroyWindow01
static int tolua_CEGUI_CEGUI_WindowManager_destroyWindow01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::WindowManager* self = (CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* window = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyWindow'",NULL);
#endif
 {
  self->destroyWindow(window);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_WindowManager_destroyWindow00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyAllWindows of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_destroyAllWindows00
static int tolua_CEGUI_CEGUI_WindowManager_destroyAllWindows00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowManager* self = (CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyAllWindows'",NULL);
#endif
 {
  self->destroyAllWindows();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyAllWindows'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWindow of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_getWindow00
static int tolua_CEGUI_CEGUI_WindowManager_getWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowManager* self = (const CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWindow'",NULL);
#endif
 try
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getWindow(name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
catch(CEGUI::UnknownObjectException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isWindowPresent of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_isWindowPresent00
static int tolua_CEGUI_CEGUI_WindowManager_isWindowPresent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowManager* self = (const CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isWindowPresent'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isWindowPresent(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isWindowPresent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: cleanDeadPool of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_cleanDeadPool00
static int tolua_CEGUI_CEGUI_WindowManager_cleanDeadPool00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowManager* self = (CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cleanDeadPool'",NULL);
#endif
 {
  self->cleanDeadPool();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'cleanDeadPool'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: renameWindow of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_renameWindow00
static int tolua_CEGUI_CEGUI_WindowManager_renameWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowManager* self = (CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* window = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  utf8string new_name = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'renameWindow'",NULL);
#endif
 {
  self->renameWindow(window,new_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'renameWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: renameWindow of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_renameWindow01
static int tolua_CEGUI_CEGUI_WindowManager_renameWindow01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::WindowManager* self = (CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string window = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string new_name = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'renameWindow'",NULL);
#endif
 {
  self->renameWindow(window,new_name);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_WindowManager_renameWindow00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIterator of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_getIterator00
static int tolua_CEGUI_CEGUI_WindowManager_getIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowManager* self = (const CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIterator'",NULL);
#endif
 {
  CEGUI::WindowIterator tolua_ret = (CEGUI::WindowIterator)  self->getIterator();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::WindowIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::WindowIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::WindowIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::WindowIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDefaultResourceGroup of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_setDefaultResourceGroup00
static int tolua_CEGUI_CEGUI_WindowManager_setDefaultResourceGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string resourceGroup = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::WindowManager::setDefaultResourceGroup(resourceGroup);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDefaultResourceGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultResourceGroup of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_getDefaultResourceGroup00
static int tolua_CEGUI_CEGUI_WindowManager_getDefaultResourceGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  string tolua_ret = (string)  CEGUI::WindowManager::getDefaultResourceGroup();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultResourceGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: lock of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_lock00
static int tolua_CEGUI_CEGUI_WindowManager_lock00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowManager* self = (CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lock'",NULL);
#endif
 {
  self->lock();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'lock'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: unlock of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_unlock00
static int tolua_CEGUI_CEGUI_WindowManager_unlock00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowManager* self = (CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unlock'",NULL);
#endif
 {
  self->unlock();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'unlock'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: ceguiLua_getEventIterator of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_getEventIterator00
static int tolua_CEGUI_CEGUI_WindowManager_getEventIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowManager* self = (const CEGUI::WindowManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ceguiLua_getEventIterator'",NULL);
#endif
 {
  CEGUI::EventIterator tolua_ret = (CEGUI::EventIterator)  ceguiLua_getEventIterator(self);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::EventIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::EventIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::EventIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEventIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_windowType of class  CEGUI::FalagardWindowMapping */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__FalagardWindowMapping_windowType
static int tolua_get_CEGUI__FalagardWindowMapping_windowType(lua_State* tolua_S)
{
  CEGUI::FalagardWindowMapping* self = (CEGUI::FalagardWindowMapping*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_windowType'",NULL);
#endif
 tolua_pushcppstring(tolua_S,(const char*)self->d_windowType);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_windowType of class  CEGUI::FalagardWindowMapping */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__FalagardWindowMapping_windowType
static int tolua_set_CEGUI__FalagardWindowMapping_windowType(lua_State* tolua_S)
{
  CEGUI::FalagardWindowMapping* self = (CEGUI::FalagardWindowMapping*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_windowType'",NULL);
 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_windowType = ((string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_lookName of class  CEGUI::FalagardWindowMapping */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__FalagardWindowMapping_lookName
static int tolua_get_CEGUI__FalagardWindowMapping_lookName(lua_State* tolua_S)
{
  CEGUI::FalagardWindowMapping* self = (CEGUI::FalagardWindowMapping*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_lookName'",NULL);
#endif
 tolua_pushcppstring(tolua_S,(const char*)self->d_lookName);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_lookName of class  CEGUI::FalagardWindowMapping */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__FalagardWindowMapping_lookName
static int tolua_set_CEGUI__FalagardWindowMapping_lookName(lua_State* tolua_S)
{
  CEGUI::FalagardWindowMapping* self = (CEGUI::FalagardWindowMapping*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_lookName'",NULL);
 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_lookName = ((string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_baseType of class  CEGUI::FalagardWindowMapping */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__FalagardWindowMapping_baseType
static int tolua_get_CEGUI__FalagardWindowMapping_baseType(lua_State* tolua_S)
{
  CEGUI::FalagardWindowMapping* self = (CEGUI::FalagardWindowMapping*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_baseType'",NULL);
#endif
 tolua_pushcppstring(tolua_S,(const char*)self->d_baseType);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_baseType of class  CEGUI::FalagardWindowMapping */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__FalagardWindowMapping_baseType
static int tolua_set_CEGUI__FalagardWindowMapping_baseType(lua_State* tolua_S)
{
  CEGUI::FalagardWindowMapping* self = (CEGUI::FalagardWindowMapping*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_baseType'",NULL);
 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_baseType = ((string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_rendererType of class  CEGUI::FalagardWindowMapping */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__FalagardWindowMapping_rendererType
static int tolua_get_CEGUI__FalagardWindowMapping_rendererType(lua_State* tolua_S)
{
  CEGUI::FalagardWindowMapping* self = (CEGUI::FalagardWindowMapping*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_rendererType'",NULL);
#endif
 tolua_pushcppstring(tolua_S,(const char*)self->d_rendererType);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_rendererType of class  CEGUI::FalagardWindowMapping */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__FalagardWindowMapping_rendererType
static int tolua_set_CEGUI__FalagardWindowMapping_rendererType(lua_State* tolua_S)
{
  CEGUI::FalagardWindowMapping* self = (CEGUI::FalagardWindowMapping*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_rendererType'",NULL);
 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_rendererType = ((string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_effectName of class  CEGUI::FalagardWindowMapping */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__FalagardWindowMapping_effectName
static int tolua_get_CEGUI__FalagardWindowMapping_effectName(lua_State* tolua_S)
{
  CEGUI::FalagardWindowMapping* self = (CEGUI::FalagardWindowMapping*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_effectName'",NULL);
#endif
 tolua_pushcppstring(tolua_S,(const char*)self->d_effectName);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_effectName of class  CEGUI::FalagardWindowMapping */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__FalagardWindowMapping_effectName
static int tolua_set_CEGUI__FalagardWindowMapping_effectName(lua_State* tolua_S)
{
  CEGUI::FalagardWindowMapping* self = (CEGUI::FalagardWindowMapping*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_effectName'",NULL);
 if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_effectName = ((string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTypeName of class  CEGUI::WindowFactory */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactory_getTypeName00
static int tolua_CEGUI_CEGUI_WindowFactory_getTypeName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowFactory",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactory* self = (const CEGUI::WindowFactory*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTypeName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getTypeName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTypeName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_getSingleton00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::WindowFactoryManager& tolua_ret = (CEGUI::WindowFactoryManager&)  CEGUI::WindowFactoryManager::getSingleton();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::WindowFactoryManager");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isFactoryPresent of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_isFactoryPresent00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_isFactoryPresent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactoryManager* self = (const CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isFactoryPresent'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isFactoryPresent(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isFactoryPresent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addWindowTypeAlias of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_addWindowTypeAlias00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_addWindowTypeAlias00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowFactoryManager* self = (CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string aliasName = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string targetType = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addWindowTypeAlias'",NULL);
#endif
 {
  self->addWindowTypeAlias(aliasName,targetType);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addWindowTypeAlias'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeWindowTypeAlias of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_removeWindowTypeAlias00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_removeWindowTypeAlias00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowFactoryManager* self = (CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string aliasName = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string targetType = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeWindowTypeAlias'",NULL);
#endif
 {
  self->removeWindowTypeAlias(aliasName,targetType);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeWindowTypeAlias'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addFalagardWindowMapping of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_addFalagardWindowMapping00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_addFalagardWindowMapping00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,5,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,6,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowFactoryManager* self = (CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string newType = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string targetType = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  utf8string lookName = ((utf8string)  tolua_toutf8string(tolua_S,4,0));
  utf8string renderer = ((utf8string)  tolua_toutf8string(tolua_S,5,0));
  utf8string effectName = ((utf8string)  tolua_toutf8string(tolua_S,6,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addFalagardWindowMapping'",NULL);
#endif
 {
  self->addFalagardWindowMapping(newType,targetType,lookName,renderer,effectName);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addFalagardWindowMapping'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeFalagardWindowMapping of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_removeFalagardWindowMapping00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_removeFalagardWindowMapping00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowFactoryManager* self = (CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string type = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeFalagardWindowMapping'",NULL);
#endif
 {
  self->removeFalagardWindowMapping(type);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeFalagardWindowMapping'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isFalagardMappedType of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_isFalagardMappedType00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_isFalagardMappedType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactoryManager* self = (const CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string type = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isFalagardMappedType'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isFalagardMappedType(type);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isFalagardMappedType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMappedLookForType of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_getMappedLookForType00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_getMappedLookForType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactoryManager* self = (const CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string type = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMappedLookForType'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getMappedLookForType(type);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMappedLookForType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMappedRendererForType of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_getMappedRendererForType00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_getMappedRendererForType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactoryManager* self = (const CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string type = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMappedRendererForType'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getMappedRendererForType(type);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMappedRendererForType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDereferencedAliasType of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_getDereferencedAliasType00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_getDereferencedAliasType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactoryManager* self = (const CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string type = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDereferencedAliasType'",NULL);
#endif
 {
  CEGUI::String tolua_ret = (CEGUI::String)  self->getDereferencedAliasType(type);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::String(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::String");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::String));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::String");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDereferencedAliasType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFalagardMappingForType of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_getFalagardMappingForType00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_getFalagardMappingForType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactoryManager* self = (const CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string type = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFalagardMappingForType'",NULL);
#endif
 {
  const CEGUI::FalagardWindowMapping& tolua_ret = (const CEGUI::FalagardWindowMapping&)  self->getFalagardMappingForType(type);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::FalagardWindowMapping");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFalagardMappingForType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIterator of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_getIterator00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_getIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactoryManager* self = (const CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIterator'",NULL);
#endif
 {
  CEGUI::WindowFactoryIterator tolua_ret = (CEGUI::WindowFactoryIterator)  self->getIterator();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::WindowFactoryIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::WindowFactoryIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::WindowFactoryIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::WindowFactoryIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFalagardMappingIterator of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_getFalagardMappingIterator00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_getFalagardMappingIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WindowFactoryManager* self = (const CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFalagardMappingIterator'",NULL);
#endif
 {
  CEGUI::FalagardMappingIterator tolua_ret = (CEGUI::FalagardMappingIterator)  self->getFalagardMappingIterator();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::FalagardMappingIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::FalagardMappingIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::FalagardMappingIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::FalagardMappingIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFalagardMappingIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: loadResources of class  CEGUI::Scheme */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scheme_loadResources00
static int tolua_CEGUI_CEGUI_Scheme_loadResources00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Scheme",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Scheme* self = (CEGUI::Scheme*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadResources'",NULL);
#endif
 {
  self->loadResources();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadResources'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: unloadResources of class  CEGUI::Scheme */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scheme_unloadResources00
static int tolua_CEGUI_CEGUI_Scheme_unloadResources00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Scheme",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Scheme* self = (CEGUI::Scheme*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unloadResources'",NULL);
#endif
 {
  self->unloadResources();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'unloadResources'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getName of class  CEGUI::Scheme */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scheme_getName00
static int tolua_CEGUI_CEGUI_Scheme_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Scheme",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Scheme* self = (const CEGUI::Scheme*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDefaultResourceGroup of class  CEGUI::Scheme */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scheme_setDefaultResourceGroup00
static int tolua_CEGUI_CEGUI_Scheme_setDefaultResourceGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Scheme",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string resourceGroup = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::Scheme::setDefaultResourceGroup(resourceGroup);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDefaultResourceGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultResourceGroup of class  CEGUI::Scheme */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scheme_getDefaultResourceGroup00
static int tolua_CEGUI_CEGUI_Scheme_getDefaultResourceGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Scheme",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  string tolua_ret = (string)  CEGUI::Scheme::getDefaultResourceGroup();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultResourceGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  CEGUI::SchemeManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeManager_getSingleton00
static int tolua_CEGUI_CEGUI_SchemeManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::SchemeManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::SchemeManager& tolua_ret = (CEGUI::SchemeManager&)  CEGUI::SchemeManager::getSingleton();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::SchemeManager");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  CEGUI::SchemeManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeManager_create00
static int tolua_CEGUI_CEGUI_SchemeManager_create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SchemeManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SchemeManager* self = (CEGUI::SchemeManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string filename = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string resourcegroup = ((utf8string)  tolua_toutf8string(tolua_S,3,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create'",NULL);
#endif
 {
  CEGUI::Scheme& tolua_ret = (CEGUI::Scheme&)  self->create(filename,resourcegroup);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Scheme");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroy of class  CEGUI::SchemeManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeManager_destroy00
static int tolua_CEGUI_CEGUI_SchemeManager_destroy00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SchemeManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SchemeManager* self = (CEGUI::SchemeManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroy'",NULL);
#endif
 {
  self->destroy(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroy'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isDefined of class  CEGUI::SchemeManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeManager_isDefined00
static int tolua_CEGUI_CEGUI_SchemeManager_isDefined00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SchemeManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SchemeManager* self = (const CEGUI::SchemeManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isDefined'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isDefined(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isDefined'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  CEGUI::SchemeManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeManager_get00
static int tolua_CEGUI_CEGUI_SchemeManager_get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SchemeManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SchemeManager* self = (const CEGUI::SchemeManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  CEGUI::Scheme& tolua_ret = (CEGUI::Scheme&)  self->get(name);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Scheme");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyAll of class  CEGUI::SchemeManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeManager_destroyAll00
static int tolua_CEGUI_CEGUI_SchemeManager_destroyAll00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SchemeManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SchemeManager* self = (CEGUI::SchemeManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyAll'",NULL);
#endif
 {
  self->destroyAll();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyAll'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIterator of class  CEGUI::SchemeManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeManager_getIterator00
static int tolua_CEGUI_CEGUI_SchemeManager_getIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SchemeManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SchemeManager* self = (const CEGUI::SchemeManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIterator'",NULL);
#endif
 {
  CEGUI::SchemeIterator tolua_ret = (CEGUI::SchemeIterator)  self->getIterator();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::SchemeIterator(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::SchemeIterator");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::SchemeIterator));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::SchemeIterator");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIterator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToFloat of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToFloat00
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToFloat00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string str = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  float tolua_ret = (float)  CEGUI::PropertyHelper::stringToFloat(str);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToFloat'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToUint of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToUint00
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToUint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string str = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  unsigned int tolua_ret = (unsigned int)  CEGUI::PropertyHelper::stringToUint(str);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToUint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToBool of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToBool00
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToBool00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string str = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  bool tolua_ret = (bool)  CEGUI::PropertyHelper::stringToBool(str);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToBool'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToSize of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToSize00
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string str = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::Size tolua_ret = (CEGUI::Size)  CEGUI::PropertyHelper::stringToSize(str);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToPoint of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToPoint00
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToPoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string str = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::Vector2 tolua_ret = (CEGUI::Vector2)  CEGUI::PropertyHelper::stringToPoint(str);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToPoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToRect of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToRect00
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string str = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  CEGUI::PropertyHelper::stringToRect(str);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToRect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToImage of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToImage00
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string str = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  CEGUI::PropertyHelper::stringToImage(str);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToColour of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToColour00
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToColour00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string str = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::colour tolua_ret = (CEGUI::colour)  CEGUI::PropertyHelper::stringToColour(str);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::colour(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::colour");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::colour));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::colour");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToColour'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToColourRect of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToColourRect00
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToColourRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string str = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::ColourRect tolua_ret = (CEGUI::ColourRect)  CEGUI::PropertyHelper::stringToColourRect(str);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::ColourRect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ColourRect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::ColourRect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ColourRect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToColourRect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToUDim of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToUDim00
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToUDim00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string str = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::UDim tolua_ret = (CEGUI::UDim)  CEGUI::PropertyHelper::stringToUDim(str);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UDim(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UDim));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToUDim'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToUVector2 of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToUVector200
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToUVector200(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string str = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::UVector2 tolua_ret = (CEGUI::UVector2)  CEGUI::PropertyHelper::stringToUVector2(str);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UVector2(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UVector2));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UVector2");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToUVector2'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToURect of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToURect00
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToURect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string str = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::URect tolua_ret = (CEGUI::URect)  CEGUI::PropertyHelper::stringToURect(str);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::URect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::URect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::URect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::URect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToURect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: floatToString of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_floatToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_floatToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  float val = ((float)  tolua_tonumber(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::PropertyHelper::floatToString(val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'floatToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: uintToString of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_uintToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_uintToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  unsigned int val = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::PropertyHelper::uintToString(val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'uintToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: boolToString of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_boolToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_boolToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  bool val = ((bool)  tolua_toboolean(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::PropertyHelper::boolToString(val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'boolToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sizeToString of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_sizeToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_sizeToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Size* val = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::PropertyHelper::sizeToString(*val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sizeToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: pointToString of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_pointToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_pointToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Vector2* val = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::PropertyHelper::pointToString(*val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'pointToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: rectToString of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_rectToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_rectToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect* val = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::PropertyHelper::rectToString(*val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'rectToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: imageToString of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_imageToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_imageToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Image* val = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::PropertyHelper::imageToString(val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'imageToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: colourToString of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_colourToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_colourToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::colour* val = ((const CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::PropertyHelper::colourToString(*val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'colourToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: colourRectToString of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_colourRectToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_colourRectToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ColourRect* val = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::PropertyHelper::colourRectToString(*val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'colourRectToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: udimToString of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_udimToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_udimToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UDim* val = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::PropertyHelper::udimToString(*val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'udimToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: uvector2ToString of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_uvector2ToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_uvector2ToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UVector2* val = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::PropertyHelper::uvector2ToString(*val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'uvector2ToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: urectToString of class  CEGUI::PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_urectToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_urectToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyHelper",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::URect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::URect* val = ((const CEGUI::URect*)  tolua_tousertype(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::PropertyHelper::urectToString(*val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'urectToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: position of class  CEGUI::Vertex */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Vertex_position
static int tolua_get_CEGUI__Vertex_position(lua_State* tolua_S)
{
  CEGUI::Vertex* self = (CEGUI::Vertex*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'position'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->position,"CEGUI::Vector3");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: position of class  CEGUI::Vertex */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Vertex_position
static int tolua_set_CEGUI__Vertex_position(lua_State* tolua_S)
{
  CEGUI::Vertex* self = (CEGUI::Vertex*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'position'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::Vector3",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->position = *((CEGUI::Vector3*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: tex_coords of class  CEGUI::Vertex */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Vertex_tex_coords
static int tolua_get_CEGUI__Vertex_tex_coords(lua_State* tolua_S)
{
  CEGUI::Vertex* self = (CEGUI::Vertex*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tex_coords'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->tex_coords,"CEGUI::Vector2");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: tex_coords of class  CEGUI::Vertex */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Vertex_tex_coords
static int tolua_set_CEGUI__Vertex_tex_coords(lua_State* tolua_S)
{
  CEGUI::Vertex* self = (CEGUI::Vertex*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'tex_coords'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::Vector2",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->tex_coords = *((CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: colour_val of class  CEGUI::Vertex */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Vertex_colour_val
static int tolua_get_CEGUI__Vertex_colour_val(lua_State* tolua_S)
{
  CEGUI::Vertex* self = (CEGUI::Vertex*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'colour_val'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->colour_val,"CEGUI::colour");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: colour_val of class  CEGUI::Vertex */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Vertex_colour_val
static int tolua_set_CEGUI__Vertex_colour_val(lua_State* tolua_S)
{
  CEGUI::Vertex* self = (CEGUI::Vertex*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'colour_val'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::colour",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->colour_val = *((CEGUI::colour*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: surface of class  CEGUI::RenderingContext */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__RenderingContext_surface_ptr
static int tolua_get_CEGUI__RenderingContext_surface_ptr(lua_State* tolua_S)
{
  CEGUI::RenderingContext* self = (CEGUI::RenderingContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'surface'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)self->surface,"CEGUI::RenderingSurface");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: surface of class  CEGUI::RenderingContext */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__RenderingContext_surface_ptr
static int tolua_set_CEGUI__RenderingContext_surface_ptr(lua_State* tolua_S)
{
  CEGUI::RenderingContext* self = (CEGUI::RenderingContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'surface'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::RenderingSurface",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->surface = ((CEGUI::RenderingSurface*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: owner of class  CEGUI::RenderingContext */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__RenderingContext_owner_ptr
static int tolua_get_CEGUI__RenderingContext_owner_ptr(lua_State* tolua_S)
{
  CEGUI::RenderingContext* self = (CEGUI::RenderingContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'owner'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)self->owner,"const CEGUI::Window");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: offset of class  CEGUI::RenderingContext */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__RenderingContext_offset
static int tolua_get_CEGUI__RenderingContext_offset(lua_State* tolua_S)
{
  CEGUI::RenderingContext* self = (CEGUI::RenderingContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'offset'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->offset,"CEGUI::Vector2");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: offset of class  CEGUI::RenderingContext */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__RenderingContext_offset
static int tolua_set_CEGUI__RenderingContext_offset(lua_State* tolua_S)
{
  CEGUI::RenderingContext* self = (CEGUI::RenderingContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'offset'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::Vector2",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->offset = *((CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: draw of class  CEGUI::GeometryBuffer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GeometryBuffer_draw00
static int tolua_CEGUI_CEGUI_GeometryBuffer_draw00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::GeometryBuffer* self = (const CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'draw'",NULL);
#endif
 {
  self->draw();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'draw'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTranslation of class  CEGUI::GeometryBuffer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GeometryBuffer_setTranslation00
static int tolua_CEGUI_CEGUI_GeometryBuffer_setTranslation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GeometryBuffer* self = (CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector3* v = ((const CEGUI::Vector3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTranslation'",NULL);
#endif
 {
  self->setTranslation(*v);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTranslation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRotation of class  CEGUI::GeometryBuffer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GeometryBuffer_setRotation00
static int tolua_CEGUI_CEGUI_GeometryBuffer_setRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GeometryBuffer* self = (CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector3* r = ((const CEGUI::Vector3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRotation'",NULL);
#endif
 {
  self->setRotation(*r);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPivot of class  CEGUI::GeometryBuffer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GeometryBuffer_setPivot00
static int tolua_CEGUI_CEGUI_GeometryBuffer_setPivot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GeometryBuffer* self = (CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector3* p = ((const CEGUI::Vector3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPivot'",NULL);
#endif
 {
  self->setPivot(*p);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPivot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: appendVertex of class  CEGUI::GeometryBuffer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GeometryBuffer_appendVertex00
static int tolua_CEGUI_CEGUI_GeometryBuffer_appendVertex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vertex",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GeometryBuffer* self = (CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vertex* vertex = ((const CEGUI::Vertex*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'appendVertex'",NULL);
#endif
 {
  self->appendVertex(*vertex);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'appendVertex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: appendGeometry of class  CEGUI::GeometryBuffer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GeometryBuffer_appendGeometry00
static int tolua_CEGUI_CEGUI_GeometryBuffer_appendGeometry00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vertex",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GeometryBuffer* self = (CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vertex* vbuff = ((const CEGUI::Vertex*)  tolua_tousertype(tolua_S,2,0));
  unsigned int vertex_count = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'appendGeometry'",NULL);
#endif
 {
  self->appendGeometry(vbuff,vertex_count);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'appendGeometry'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setActiveTexture of class  CEGUI::GeometryBuffer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GeometryBuffer_setActiveTexture00
static int tolua_CEGUI_CEGUI_GeometryBuffer_setActiveTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Texture",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GeometryBuffer* self = (CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Texture* texture = ((CEGUI::Texture*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setActiveTexture'",NULL);
#endif
 {
  self->setActiveTexture(texture);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setActiveTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: reset of class  CEGUI::GeometryBuffer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GeometryBuffer_reset00
static int tolua_CEGUI_CEGUI_GeometryBuffer_reset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GeometryBuffer* self = (CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'reset'",NULL);
#endif
 {
  self->reset();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'reset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getActiveTexture of class  CEGUI::GeometryBuffer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GeometryBuffer_getActiveTexture00
static int tolua_CEGUI_CEGUI_GeometryBuffer_getActiveTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::GeometryBuffer* self = (const CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getActiveTexture'",NULL);
#endif
 {
  CEGUI::Texture* tolua_ret = (CEGUI::Texture*)  self->getActiveTexture();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Texture");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getActiveTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVertexCount of class  CEGUI::GeometryBuffer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GeometryBuffer_getVertexCount00
static int tolua_CEGUI_CEGUI_GeometryBuffer_getVertexCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::GeometryBuffer* self = (const CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVertexCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getVertexCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVertexCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBatchCount of class  CEGUI::GeometryBuffer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GeometryBuffer_getBatchCount00
static int tolua_CEGUI_CEGUI_GeometryBuffer_getBatchCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::GeometryBuffer* self = (const CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBatchCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getBatchCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBatchCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRenderEffect of class  CEGUI::GeometryBuffer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GeometryBuffer_setRenderEffect00
static int tolua_CEGUI_CEGUI_GeometryBuffer_setRenderEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::RenderEffect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GeometryBuffer* self = (CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::RenderEffect* effect = ((CEGUI::RenderEffect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRenderEffect'",NULL);
#endif
 {
  self->setRenderEffect(effect);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRenderEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRenderEffect of class  CEGUI::GeometryBuffer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GeometryBuffer_getRenderEffect00
static int tolua_CEGUI_CEGUI_GeometryBuffer_getRenderEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GeometryBuffer* self = (CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRenderEffect'",NULL);
#endif
 {
  CEGUI::RenderEffect* tolua_ret = (CEGUI::RenderEffect*)  self->getRenderEffect();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::RenderEffect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRenderEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addGeometryBuffer of class  CEGUI::RenderingSurface */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingSurface_addGeometryBuffer00
static int tolua_CEGUI_CEGUI_RenderingSurface_addGeometryBuffer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingSurface",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderingSurface* self = (CEGUI::RenderingSurface*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::RenderQueueID queue = ((CEGUI::RenderQueueID) (int)  tolua_tonumber(tolua_S,2,0));
  const CEGUI::GeometryBuffer* buffer = ((const CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addGeometryBuffer'",NULL);
#endif
 {
  self->addGeometryBuffer(queue,*buffer);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addGeometryBuffer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeGeometryBuffer of class  CEGUI::RenderingSurface */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingSurface_removeGeometryBuffer00
static int tolua_CEGUI_CEGUI_RenderingSurface_removeGeometryBuffer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingSurface",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderingSurface* self = (CEGUI::RenderingSurface*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::RenderQueueID queue = ((CEGUI::RenderQueueID) (int)  tolua_tonumber(tolua_S,2,0));
  const CEGUI::GeometryBuffer* buffer = ((const CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeGeometryBuffer'",NULL);
#endif
 {
  self->removeGeometryBuffer(queue,*buffer);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeGeometryBuffer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearGeometry of class  CEGUI::RenderingSurface */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingSurface_clearGeometry00
static int tolua_CEGUI_CEGUI_RenderingSurface_clearGeometry00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingSurface",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderingSurface* self = (CEGUI::RenderingSurface*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::RenderQueueID queue = ((CEGUI::RenderQueueID) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearGeometry'",NULL);
#endif
 {
  self->clearGeometry(queue);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearGeometry'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearGeometry of class  CEGUI::RenderingSurface */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingSurface_clearGeometry01
static int tolua_CEGUI_CEGUI_RenderingSurface_clearGeometry01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingSurface",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::RenderingSurface* self = (CEGUI::RenderingSurface*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearGeometry'",NULL);
#endif
 {
  self->clearGeometry();
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_RenderingSurface_clearGeometry00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: invalidate of class  CEGUI::RenderingSurface */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingSurface_invalidate00
static int tolua_CEGUI_CEGUI_RenderingSurface_invalidate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingSurface",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderingSurface* self = (CEGUI::RenderingSurface*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'invalidate'",NULL);
#endif
 {
  self->invalidate();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'invalidate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: transferRenderingWindow of class  CEGUI::RenderingSurface */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingSurface_transferRenderingWindow00
static int tolua_CEGUI_CEGUI_RenderingSurface_transferRenderingWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingSurface",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderingSurface* self = (CEGUI::RenderingSurface*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::RenderingWindow* window = ((CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'transferRenderingWindow'",NULL);
#endif
 {
  self->transferRenderingWindow(*window);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'transferRenderingWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setClippingRegion of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_setClippingRegion00
static int tolua_CEGUI_CEGUI_RenderingWindow_setClippingRegion00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderingWindow* self = (CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Rect* region = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setClippingRegion'",NULL);
#endif
 {
  self->setClippingRegion(*region);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setClippingRegion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPosition of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_setPosition00
static int tolua_CEGUI_CEGUI_RenderingWindow_setPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderingWindow* self = (CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* position = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPosition'",NULL);
#endif
 {
  self->setPosition(*position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSize of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_setSize00
static int tolua_CEGUI_CEGUI_RenderingWindow_setSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderingWindow* self = (CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* size = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSize'",NULL);
#endif
 {
  self->setSize(*size);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRotation of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_setRotation00
static int tolua_CEGUI_CEGUI_RenderingWindow_setRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderingWindow* self = (CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector3* rotation = ((const CEGUI::Vector3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRotation'",NULL);
#endif
 {
  self->setRotation(*rotation);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPivot of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_setPivot00
static int tolua_CEGUI_CEGUI_RenderingWindow_setPivot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector3",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderingWindow* self = (CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector3* pivot = ((const CEGUI::Vector3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPivot'",NULL);
#endif
 {
  self->setPivot(*pivot);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPivot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPosition of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_getPosition00
static int tolua_CEGUI_CEGUI_RenderingWindow_getPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::RenderingWindow* self = (const CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPosition'",NULL);
#endif
 {
  const CEGUI::Vector2& tolua_ret = (const CEGUI::Vector2&)  self->getPosition();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector2");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSize of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_getSize00
static int tolua_CEGUI_CEGUI_RenderingWindow_getSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::RenderingWindow* self = (const CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSize'",NULL);
#endif
 {
  const CEGUI::Size& tolua_ret = (const CEGUI::Size&)  self->getSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size");
 }
 }
 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: getRotation of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_getRotation00
static int tolua_CEGUI_CEGUI_RenderingWindow_getRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::RenderingWindow* self = (const CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRotation'",NULL);
#endif
 {
  const CEGUI::Vector3& tolua_ret = (const CEGUI::Vector3&)  self->getRotation();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector3");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPivot of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_getPivot00
static int tolua_CEGUI_CEGUI_RenderingWindow_getPivot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::RenderingWindow* self = (const CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPivot'",NULL);
#endif
 {
  const CEGUI::Vector3& tolua_ret = (const CEGUI::Vector3&)  self->getPivot();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector3");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPivot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRenderEffect of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_setRenderEffect00
static int tolua_CEGUI_CEGUI_RenderingWindow_setRenderEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::RenderEffect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderingWindow* self = (CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::RenderEffect* effect = ((CEGUI::RenderEffect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRenderEffect'",NULL);
#endif
 {
  self->setRenderEffect(effect);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRenderEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRenderEffect of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_getRenderEffect00
static int tolua_CEGUI_CEGUI_RenderingWindow_getRenderEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderingWindow* self = (CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRenderEffect'",NULL);
#endif
 {
  CEGUI::RenderEffect* tolua_ret = (CEGUI::RenderEffect*)  self->getRenderEffect();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::RenderEffect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRenderEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOwner of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_getOwner00
static int tolua_CEGUI_CEGUI_RenderingWindow_getOwner00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::RenderingWindow* self = (const CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOwner'",NULL);
#endif
 {
  const CEGUI::RenderingSurface& tolua_ret = (const CEGUI::RenderingSurface&)  self->getOwner();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::RenderingSurface");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOwner'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOwner of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_getOwner01
static int tolua_CEGUI_CEGUI_RenderingWindow_getOwner01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::RenderingWindow* self = (CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOwner'",NULL);
#endif
 {
  CEGUI::RenderingSurface& tolua_ret = (CEGUI::RenderingSurface&)  self->getOwner();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::RenderingSurface");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_RenderingWindow_getOwner00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: unprojectPoint of class  CEGUI::RenderingWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderingWindow_unprojectPoint00
static int tolua_CEGUI_CEGUI_RenderingWindow_unprojectPoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderingWindow",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderingWindow* self = (CEGUI::RenderingWindow*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* p_in = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Vector2* p_out = ((CEGUI::Vector2*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unprojectPoint'",NULL);
#endif
 {
  self->unprojectPoint(*p_in,*p_out);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'unprojectPoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultRenderingRoot of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_getDefaultRenderingRoot00
static int tolua_CEGUI_CEGUI_Renderer_getDefaultRenderingRoot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Renderer* self = (CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDefaultRenderingRoot'",NULL);
#endif
 {
  CEGUI::RenderingRoot& tolua_ret = (CEGUI::RenderingRoot&)  self->getDefaultRenderingRoot();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::RenderingRoot");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultRenderingRoot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createGeometryBuffer of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_createGeometryBuffer00
static int tolua_CEGUI_CEGUI_Renderer_createGeometryBuffer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Renderer* self = (CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createGeometryBuffer'",NULL);
#endif
 {
  CEGUI::GeometryBuffer& tolua_ret = (CEGUI::GeometryBuffer&)  self->createGeometryBuffer();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::GeometryBuffer");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createGeometryBuffer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyGeometryBuffer of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_destroyGeometryBuffer00
static int tolua_CEGUI_CEGUI_Renderer_destroyGeometryBuffer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Renderer* self = (CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::GeometryBuffer* buffer = ((const CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyGeometryBuffer'",NULL);
#endif
 {
  self->destroyGeometryBuffer(*buffer);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyGeometryBuffer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyAllGeometryBuffers of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_destroyAllGeometryBuffers00
static int tolua_CEGUI_CEGUI_Renderer_destroyAllGeometryBuffers00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Renderer* self = (CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyAllGeometryBuffers'",NULL);
#endif
 {
  self->destroyAllGeometryBuffers();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyAllGeometryBuffers'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createTexture of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_createTexture00
static int tolua_CEGUI_CEGUI_Renderer_createTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Renderer* self = (CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createTexture'",NULL);
#endif
 {
  CEGUI::Texture& tolua_ret = (CEGUI::Texture&)  self->createTexture();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Texture");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createTexture of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_createTexture01
static int tolua_CEGUI_CEGUI_Renderer_createTexture01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Renderer* self = (CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
  utf8string filename = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string resourceGroup = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createTexture'",NULL);
#endif
 {
  CEGUI::Texture& tolua_ret = (CEGUI::Texture&)  self->createTexture(filename,resourceGroup);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Texture");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Renderer_createTexture00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: createTexture of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_createTexture02
static int tolua_CEGUI_CEGUI_Renderer_createTexture02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Renderer* self = (CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* size = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createTexture'",NULL);
#endif
 {
  CEGUI::Texture& tolua_ret = (CEGUI::Texture&)  self->createTexture(*size);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Texture");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Renderer_createTexture01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyTexture of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_destroyTexture00
static int tolua_CEGUI_CEGUI_Renderer_destroyTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Texture",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Renderer* self = (CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Texture* texture = ((CEGUI::Texture*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyTexture'",NULL);
#endif
 {
  self->destroyTexture(*texture);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyAllTextures of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_destroyAllTextures00
static int tolua_CEGUI_CEGUI_Renderer_destroyAllTextures00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Renderer* self = (CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyAllTextures'",NULL);
#endif
 {
  self->destroyAllTextures();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyAllTextures'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDisplaySize of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_setDisplaySize00
static int tolua_CEGUI_CEGUI_Renderer_setDisplaySize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Renderer* self = (CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size* sz = ((const CEGUI::Size*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDisplaySize'",NULL);
#endif
 {
  self->setDisplaySize(*sz);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDisplaySize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDisplaySize of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_getDisplaySize00
static int tolua_CEGUI_CEGUI_Renderer_getDisplaySize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Renderer* self = (const CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDisplaySize'",NULL);
#endif
 {
  const CEGUI::Size& tolua_ret = (const CEGUI::Size&)  self->getDisplaySize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDisplaySize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDisplayDPI of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_getDisplayDPI00
static int tolua_CEGUI_CEGUI_Renderer_getDisplayDPI00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Renderer* self = (const CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDisplayDPI'",NULL);
#endif
 {
  const CEGUI::Vector2& tolua_ret = (const CEGUI::Vector2&)  self->getDisplayDPI();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector2");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDisplayDPI'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMaxTextureSize of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_getMaxTextureSize00
static int tolua_CEGUI_CEGUI_Renderer_getMaxTextureSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Renderer* self = (const CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMaxTextureSize'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getMaxTextureSize();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMaxTextureSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getIdentifierString of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_getIdentifierString00
static int tolua_CEGUI_CEGUI_Renderer_getIdentifierString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Renderer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Renderer* self = (const CEGUI::Renderer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIdentifierString'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getIdentifierString();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getIdentifierString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSize of class  CEGUI::Texture */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Texture_getSize00
static int tolua_CEGUI_CEGUI_Texture_getSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Texture",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Texture* self = (const CEGUI::Texture*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSize'",NULL);
#endif
 {
  const CEGUI::Size& tolua_ret = (const CEGUI::Size&)  self->getSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size");
 }
 }
 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: getOriginalDataSize of class  CEGUI::Texture */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Texture_getOriginalDataSize00
static int tolua_CEGUI_CEGUI_Texture_getOriginalDataSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Texture",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Texture* self = (const CEGUI::Texture*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOriginalDataSize'",NULL);
#endif
 {
  const CEGUI::Size& tolua_ret = (const CEGUI::Size&)  self->getOriginalDataSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOriginalDataSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTexelScaling of class  CEGUI::Texture */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Texture_getTexelScaling00
static int tolua_CEGUI_CEGUI_Texture_getTexelScaling00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Texture",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Texture* self = (const CEGUI::Texture*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTexelScaling'",NULL);
#endif
 {
  const CEGUI::Vector2& tolua_ret = (const CEGUI::Vector2&)  self->getTexelScaling();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector2");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTexelScaling'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: loadFromFile of class  CEGUI::Texture */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Texture_loadFromFile00
static int tolua_CEGUI_CEGUI_Texture_loadFromFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Texture",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Texture* self = (CEGUI::Texture*)  tolua_tousertype(tolua_S,1,0);
  utf8string filename = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string resourceGroup = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadFromFile'",NULL);
#endif
 {
  self->loadFromFile(filename,resourceGroup);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadFromFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getParent of class  CEGUI::KeyFrame */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_KeyFrame_getParent00
static int tolua_CEGUI_CEGUI_KeyFrame_getParent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::KeyFrame",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::KeyFrame* self = (const CEGUI::KeyFrame*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getParent'",NULL);
#endif
 {
  CEGUI::Affector* tolua_ret = (CEGUI::Affector*)  self->getParent();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Affector");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getParent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPosition of class  CEGUI::KeyFrame */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_KeyFrame_getPosition00
static int tolua_CEGUI_CEGUI_KeyFrame_getPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::KeyFrame",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::KeyFrame* self = (const CEGUI::KeyFrame*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPosition'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getPosition();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setValue of class  CEGUI::KeyFrame */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_KeyFrame_setValue00
static int tolua_CEGUI_CEGUI_KeyFrame_setValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::KeyFrame",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::KeyFrame* self = (CEGUI::KeyFrame*)  tolua_tousertype(tolua_S,1,0);
  utf8string value = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValue'",NULL);
#endif
 {
  self->setValue(value);
 }
 }
 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  CEGUI::KeyFrame */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_KeyFrame_getValue00
static int tolua_CEGUI_CEGUI_KeyFrame_getValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::KeyFrame",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::KeyFrame* self = (const CEGUI::KeyFrame*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValue'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getValue();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 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: setProgression of class  CEGUI::KeyFrame */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_KeyFrame_setProgression00
static int tolua_CEGUI_CEGUI_KeyFrame_setProgression00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::KeyFrame",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::KeyFrame* self = (CEGUI::KeyFrame*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::KeyFrame::Progression p = ((CEGUI::KeyFrame::Progression) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setProgression'",NULL);
#endif
 {
  self->setProgression(p);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setProgression'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getProgression of class  CEGUI::KeyFrame */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_KeyFrame_getProgression00
static int tolua_CEGUI_CEGUI_KeyFrame_getProgression00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::KeyFrame",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::KeyFrame* self = (const CEGUI::KeyFrame*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getProgression'",NULL);
#endif
 {
  CEGUI::KeyFrame::Progression tolua_ret = (CEGUI::KeyFrame::Progression)  self->getProgression();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getProgression'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: alterInterpolationPosition of class  CEGUI::KeyFrame */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_KeyFrame_alterInterpolationPosition00
static int tolua_CEGUI_CEGUI_KeyFrame_alterInterpolationPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::KeyFrame",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::KeyFrame* self = (CEGUI::KeyFrame*)  tolua_tousertype(tolua_S,1,0);
  float position = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'alterInterpolationPosition'",NULL);
#endif
 {
  float tolua_ret = (float)  self->alterInterpolationPosition(position);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'alterInterpolationPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setApplicationMethod of class  CEGUI::Affector */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Affector_setApplicationMethod00
static int tolua_CEGUI_CEGUI_Affector_setApplicationMethod00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Affector",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Affector* self = (CEGUI::Affector*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Affector::ApplicationMethod method = ((CEGUI::Affector::ApplicationMethod) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setApplicationMethod'",NULL);
#endif
 {
  self->setApplicationMethod(method);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setApplicationMethod'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getApplicationMethod of class  CEGUI::Affector */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Affector_getApplicationMethod00
static int tolua_CEGUI_CEGUI_Affector_getApplicationMethod00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Affector",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Affector* self = (const CEGUI::Affector*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getApplicationMethod'",NULL);
#endif
 {
  CEGUI::Affector::ApplicationMethod tolua_ret = (CEGUI::Affector::ApplicationMethod)  self->getApplicationMethod();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getApplicationMethod'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTargetProperty of class  CEGUI::Affector */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Affector_setTargetProperty00
static int tolua_CEGUI_CEGUI_Affector_setTargetProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Affector",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Affector* self = (CEGUI::Affector*)  tolua_tousertype(tolua_S,1,0);
  utf8string target = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTargetProperty'",NULL);
#endif
 {
  self->setTargetProperty(target);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTargetProperty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTargetProperty of class  CEGUI::Affector */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Affector_getTargetProperty00
static int tolua_CEGUI_CEGUI_Affector_getTargetProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Affector",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Affector* self = (const CEGUI::Affector*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTargetProperty'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getTargetProperty();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTargetProperty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setInterpolator of class  CEGUI::Affector */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Affector_setInterpolator00
static int tolua_CEGUI_CEGUI_Affector_setInterpolator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Affector",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Interpolator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Affector* self = (CEGUI::Affector*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Interpolator* interpolator = ((CEGUI::Interpolator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setInterpolator'",NULL);
#endif
 {
  self->setInterpolator(interpolator);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setInterpolator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setInterpolator of class  CEGUI::Affector */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Affector_setInterpolator01
static int tolua_CEGUI_CEGUI_Affector_setInterpolator01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Affector",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Affector* self = (CEGUI::Affector*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setInterpolator'",NULL);
#endif
 {
  self->setInterpolator(name);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Affector_setInterpolator00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getInterpolator of class  CEGUI::Affector */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Affector_getInterpolator00
static int tolua_CEGUI_CEGUI_Affector_getInterpolator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Affector",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Affector* self = (const CEGUI::Affector*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getInterpolator'",NULL);
#endif
 {
  CEGUI::Interpolator* tolua_ret = (CEGUI::Interpolator*)  self->getInterpolator();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Interpolator");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInterpolator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createKeyFrame of class  CEGUI::Affector */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Affector_createKeyFrame00
static int tolua_CEGUI_CEGUI_Affector_createKeyFrame00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Affector",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Affector* self = (CEGUI::Affector*)  tolua_tousertype(tolua_S,1,0);
  float position = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createKeyFrame'",NULL);
#endif
 try
 {
  CEGUI::KeyFrame* tolua_ret = (CEGUI::KeyFrame*)  self->createKeyFrame(position);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::KeyFrame");
 }
catch(CEGUI::InvalidRequestException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createKeyFrame'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createKeyFrame of class  CEGUI::Affector */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Affector_createKeyFrame01
static int tolua_CEGUI_CEGUI_Affector_createKeyFrame01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Affector",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Affector* self = (CEGUI::Affector*)  tolua_tousertype(tolua_S,1,0);
  float position = ((float)  tolua_tonumber(tolua_S,2,0));
  utf8string value = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  CEGUI::KeyFrame::Progression progression = ((CEGUI::KeyFrame::Progression) (int)  tolua_tonumber(tolua_S,4,CEGUI::KeyFrame::P_Linear));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createKeyFrame'",NULL);
#endif
 {
  CEGUI::KeyFrame* tolua_ret = (CEGUI::KeyFrame*)  self->createKeyFrame(position,value,progression);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::KeyFrame");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Affector_createKeyFrame00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyKeyFrame of class  CEGUI::Affector */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Affector_destroyKeyFrame00
static int tolua_CEGUI_CEGUI_Affector_destroyKeyFrame00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Affector",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::KeyFrame",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Affector* self = (CEGUI::Affector*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::KeyFrame* keyframe = ((CEGUI::KeyFrame*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyKeyFrame'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->destroyKeyFrame(keyframe);
 }
catch(CEGUI::InvalidRequestException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::InvalidRequestException' was thrown by function 'destroyKeyFrame'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyKeyFrame'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getKeyFrameAtPosition of class  CEGUI::Affector */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Affector_getKeyFrameAtPosition00
static int tolua_CEGUI_CEGUI_Affector_getKeyFrameAtPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Affector",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Affector* self = (const CEGUI::Affector*)  tolua_tousertype(tolua_S,1,0);
  float position = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getKeyFrameAtPosition'",NULL);
#endif
 try
 {
  CEGUI::KeyFrame* tolua_ret = (CEGUI::KeyFrame*)  self->getKeyFrameAtPosition(position);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::KeyFrame");
 }
catch(CEGUI::InvalidRequestException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getKeyFrameAtPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getKeyFrameAtIdx of class  CEGUI::Affector */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Affector_getKeyFrameAtIdx00
static int tolua_CEGUI_CEGUI_Affector_getKeyFrameAtIdx00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Affector",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Affector* self = (const CEGUI::Affector*)  tolua_tousertype(tolua_S,1,0);
  unsigned int index = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getKeyFrameAtIdx'",NULL);
#endif
 try
 {
  CEGUI::KeyFrame* tolua_ret = (CEGUI::KeyFrame*)  self->getKeyFrameAtIdx(index);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::KeyFrame");
 }
catch(CEGUI::InvalidRequestException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getKeyFrameAtIdx'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNumKeyFrames of class  CEGUI::Affector */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Affector_getNumKeyFrames00
static int tolua_CEGUI_CEGUI_Affector_getNumKeyFrames00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Affector",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Affector* self = (const CEGUI::Affector*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNumKeyFrames'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getNumKeyFrames();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNumKeyFrames'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: instance of class  CEGUI::AnimationEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__AnimationEventArgs_instance_ptr
static int tolua_get_CEGUI__AnimationEventArgs_instance_ptr(lua_State* tolua_S)
{
  CEGUI::AnimationEventArgs* self = (CEGUI::AnimationEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'instance'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)self->instance,"CEGUI::AnimationInstance");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: instance of class  CEGUI::AnimationEventArgs */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__AnimationEventArgs_instance_ptr
static int tolua_set_CEGUI__AnimationEventArgs_instance_ptr(lua_State* tolua_S)
{
  CEGUI::AnimationEventArgs* self = (CEGUI::AnimationEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'instance'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::AnimationInstance",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->instance = ((CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefinition of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_getDefinition00
static int tolua_CEGUI_CEGUI_AnimationInstance_getDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::AnimationInstance* self = (const CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDefinition'",NULL);
#endif
 {
  CEGUI::Animation* tolua_ret = (CEGUI::Animation*)  self->getDefinition();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Animation");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setEventReceiver of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_setEventReceiver00
static int tolua_CEGUI_CEGUI_AnimationInstance_setEventReceiver00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::EventSet",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationInstance* self = (CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::EventSet* receiver = ((CEGUI::EventSet*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setEventReceiver'",NULL);
#endif
 {
  self->setEventReceiver(receiver);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setEventReceiver'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEventReceiver of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_getEventReceiver00
static int tolua_CEGUI_CEGUI_AnimationInstance_getEventReceiver00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::AnimationInstance* self = (const CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEventReceiver'",NULL);
#endif
 {
  CEGUI::EventSet* tolua_ret = (CEGUI::EventSet*)  self->getEventReceiver();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::EventSet");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEventReceiver'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setEventSender of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_setEventSender00
static int tolua_CEGUI_CEGUI_AnimationInstance_setEventSender00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::EventSet",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationInstance* self = (CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::EventSet* sender = ((CEGUI::EventSet*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setEventSender'",NULL);
#endif
 {
  self->setEventSender(sender);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setEventSender'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEventSender of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_getEventSender00
static int tolua_CEGUI_CEGUI_AnimationInstance_getEventSender00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::AnimationInstance* self = (const CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEventSender'",NULL);
#endif
 {
  CEGUI::EventSet* tolua_ret = (CEGUI::EventSet*)  self->getEventSender();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::EventSet");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEventSender'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTargetWindow of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_setTargetWindow00
static int tolua_CEGUI_CEGUI_AnimationInstance_setTargetWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationInstance* self = (CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* target = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTargetWindow'",NULL);
#endif
 {
  self->setTargetWindow(target);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTargetWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPosition of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_setPosition00
static int tolua_CEGUI_CEGUI_AnimationInstance_setPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationInstance* self = (CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
  float position = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPosition'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->setPosition(position);
 }
catch(CEGUI::InvalidRequestException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::InvalidRequestException' was thrown by function 'setPosition'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPosition of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_getPosition00
static int tolua_CEGUI_CEGUI_AnimationInstance_getPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::AnimationInstance* self = (const CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPosition'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getPosition();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSpeed of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_setSpeed00
static int tolua_CEGUI_CEGUI_AnimationInstance_setSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationInstance* self = (CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
  float speed = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSpeed'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->setSpeed(speed);
 }
catch(CEGUI::InvalidRequestException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::InvalidRequestException' was thrown by function 'setSpeed'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSpeed of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_getSpeed00
static int tolua_CEGUI_CEGUI_AnimationInstance_getSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::AnimationInstance* self = (const CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSpeed'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getSpeed();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: start of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_start00
static int tolua_CEGUI_CEGUI_AnimationInstance_start00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationInstance* self = (CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
  bool skipNextStep = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'start'",NULL);
#endif
 {
  self->start(skipNextStep);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'start'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stop of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_stop00
static int tolua_CEGUI_CEGUI_AnimationInstance_stop00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationInstance* self = (CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'stop'",NULL);
#endif
 {
  self->stop();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stop'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: pause of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_pause00
static int tolua_CEGUI_CEGUI_AnimationInstance_pause00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationInstance* self = (CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pause'",NULL);
#endif
 {
  self->pause();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'pause'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: unpause of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_unpause00
static int tolua_CEGUI_CEGUI_AnimationInstance_unpause00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationInstance* self = (CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
  bool skipNextStep = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unpause'",NULL);
#endif
 {
  self->unpause(skipNextStep);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'unpause'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: togglePause of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_togglePause00
static int tolua_CEGUI_CEGUI_AnimationInstance_togglePause00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationInstance* self = (CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
  bool skipNextStep = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'togglePause'",NULL);
#endif
 {
  self->togglePause(skipNextStep);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'togglePause'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: step of class  CEGUI::AnimationInstance */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationInstance_step00
static int tolua_CEGUI_CEGUI_AnimationInstance_step00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationInstance* self = (CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,1,0);
  float delta = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'step'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->step(delta);
 }
catch(CEGUI::InvalidRequestException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::InvalidRequestException' was thrown by function 'step'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'step'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getName of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_getName00
static int tolua_CEGUI_CEGUI_Animation_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Animation",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Animation* self = (const CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setReplayMode of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_setReplayMode00
static int tolua_CEGUI_CEGUI_Animation_setReplayMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Animation* self = (CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Animation::ReplayMode mode = ((CEGUI::Animation::ReplayMode) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setReplayMode'",NULL);
#endif
 {
  self->setReplayMode(mode);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setReplayMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getReplayMode of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_getReplayMode00
static int tolua_CEGUI_CEGUI_Animation_getReplayMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Animation",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Animation* self = (const CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getReplayMode'",NULL);
#endif
 {
  CEGUI::Animation::ReplayMode tolua_ret = (CEGUI::Animation::ReplayMode)  self->getReplayMode();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getReplayMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDuration of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_setDuration00
static int tolua_CEGUI_CEGUI_Animation_setDuration00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Animation* self = (CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
  float duration = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDuration'",NULL);
#endif
 {
  self->setDuration(duration);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDuration'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDuration of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_getDuration00
static int tolua_CEGUI_CEGUI_Animation_getDuration00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Animation",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Animation* self = (const CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDuration'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getDuration();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDuration'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAutoStart of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_setAutoStart00
static int tolua_CEGUI_CEGUI_Animation_setAutoStart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Animation* self = (CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
  bool autoStart = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoStart'",NULL);
#endif
 {
  self->setAutoStart(autoStart);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoStart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: createAffector of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_createAffector00
static int tolua_CEGUI_CEGUI_Animation_createAffector00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Animation* self = (CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createAffector'",NULL);
#endif
 {
  CEGUI::Affector* tolua_ret = (CEGUI::Affector*)  self->createAffector();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Affector");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createAffector'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createAffector of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_createAffector01
static int tolua_CEGUI_CEGUI_Animation_createAffector01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Animation* self = (CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
  utf8string targetProperty = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string interpolator = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createAffector'",NULL);
#endif
 {
  CEGUI::Affector* tolua_ret = (CEGUI::Affector*)  self->createAffector(targetProperty,interpolator);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Affector");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Animation_createAffector00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyAffector of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_destroyAffector00
static int tolua_CEGUI_CEGUI_Animation_destroyAffector00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Affector",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Animation* self = (CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Affector* affector = ((CEGUI::Affector*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyAffector'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->destroyAffector(affector);
 }
catch(CEGUI::InvalidRequestException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::InvalidRequestException' was thrown by function 'destroyAffector'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyAffector'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAffectorAtIdx of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_getAffectorAtIdx00
static int tolua_CEGUI_CEGUI_Animation_getAffectorAtIdx00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Animation",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Animation* self = (const CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
  unsigned int index = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAffectorAtIdx'",NULL);
#endif
 try
 {
  CEGUI::Affector* tolua_ret = (CEGUI::Affector*)  self->getAffectorAtIdx(index);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Affector");
 }
catch(CEGUI::InvalidRequestException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAffectorAtIdx'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNumAffectors of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_getNumAffectors00
static int tolua_CEGUI_CEGUI_Animation_getNumAffectors00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Animation",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Animation* self = (const CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNumAffectors'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getNumAffectors();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNumAffectors'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: defineAutoSubscription of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_defineAutoSubscription00
static int tolua_CEGUI_CEGUI_Animation_defineAutoSubscription00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Animation* self = (CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
  utf8string eventName = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string action = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'defineAutoSubscription'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->defineAutoSubscription(eventName,action);
 }
catch(CEGUI::InvalidRequestException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::InvalidRequestException' was thrown by function 'defineAutoSubscription'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'defineAutoSubscription'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: undefineAutoSubscription of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_undefineAutoSubscription00
static int tolua_CEGUI_CEGUI_Animation_undefineAutoSubscription00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Animation* self = (CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
  utf8string eventName = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string action = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'undefineAutoSubscription'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->undefineAutoSubscription(eventName,action);
 }
catch(CEGUI::InvalidRequestException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::InvalidRequestException' was thrown by function 'undefineAutoSubscription'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'undefineAutoSubscription'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: undefineAllAutoSubscriptions of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_undefineAllAutoSubscriptions00
static int tolua_CEGUI_CEGUI_Animation_undefineAllAutoSubscriptions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Animation* self = (CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'undefineAllAutoSubscriptions'",NULL);
#endif
 {
  self->undefineAllAutoSubscriptions();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'undefineAllAutoSubscriptions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: autoSubscribe of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_autoSubscribe00
static int tolua_CEGUI_CEGUI_Animation_autoSubscribe00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Animation* self = (CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::AnimationInstance* instance = ((CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'autoSubscribe'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->autoSubscribe(instance);
 }
catch(CEGUI::InvalidRequestException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::InvalidRequestException' was thrown by function 'autoSubscribe'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'autoSubscribe'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: autoUnsubscribe of class  CEGUI::Animation */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Animation_autoUnsubscribe00
static int tolua_CEGUI_CEGUI_Animation_autoUnsubscribe00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Animation* self = (CEGUI::Animation*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::AnimationInstance* instance = ((CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'autoUnsubscribe'",NULL);
#endif
 {
  self->autoUnsubscribe(instance);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'autoUnsubscribe'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_getSingleton00
static int tolua_CEGUI_CEGUI_AnimationManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::AnimationManager& tolua_ret = (CEGUI::AnimationManager&)  CEGUI::AnimationManager::getSingleton();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::AnimationManager");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addInterpolator of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_addInterpolator00
static int tolua_CEGUI_CEGUI_AnimationManager_addInterpolator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Interpolator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationManager* self = (CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Interpolator* interpolator = ((CEGUI::Interpolator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addInterpolator'",NULL);
#endif
 try
 {
  self->addInterpolator(interpolator);
 }
catch(CEGUI::AlreadyExistsException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addInterpolator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeInterpolator of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_removeInterpolator00
static int tolua_CEGUI_CEGUI_AnimationManager_removeInterpolator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Interpolator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationManager* self = (CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Interpolator* interpolator = ((CEGUI::Interpolator*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeInterpolator'",NULL);
#endif
 try
 {
  self->removeInterpolator(interpolator);
 }
catch(CEGUI::UnknownObjectException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeInterpolator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getInterpolator of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_getInterpolator00
static int tolua_CEGUI_CEGUI_AnimationManager_getInterpolator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::AnimationManager* self = (const CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getInterpolator'",NULL);
#endif
 try
 {
  CEGUI::Interpolator* tolua_ret = (CEGUI::Interpolator*)  self->getInterpolator(name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Interpolator");
 }
catch(CEGUI::UnknownObjectException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInterpolator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createAnimation of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_createAnimation00
static int tolua_CEGUI_CEGUI_AnimationManager_createAnimation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationManager* self = (CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createAnimation'",NULL);
#endif
 try
 {
  CEGUI::Animation* tolua_ret = (CEGUI::Animation*)  self->createAnimation(name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Animation");
 }
catch(CEGUI::UnknownObjectException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createAnimation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyAnimation of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_destroyAnimation00
static int tolua_CEGUI_CEGUI_AnimationManager_destroyAnimation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationManager* self = (CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Animation* animation = ((CEGUI::Animation*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyAnimation'",NULL);
#endif
 try
 {
  self->destroyAnimation(animation);
 }
catch(CEGUI::UnknownObjectException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyAnimation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyAnimation of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_destroyAnimation01
static int tolua_CEGUI_CEGUI_AnimationManager_destroyAnimation01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::AnimationManager* self = (CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyAnimation'",NULL);
#endif
 try
 {
  self->destroyAnimation(name);
 }
catch(CEGUI::UnknownObjectException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_AnimationManager_destroyAnimation00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAnimation of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_getAnimation00
static int tolua_CEGUI_CEGUI_AnimationManager_getAnimation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::AnimationManager* self = (const CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAnimation'",NULL);
#endif
 try
 {
  CEGUI::Animation* tolua_ret = (CEGUI::Animation*)  self->getAnimation(name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Animation");
 }
catch(CEGUI::UnknownObjectException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAnimation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAnimationAtIdx of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_getAnimationAtIdx00
static int tolua_CEGUI_CEGUI_AnimationManager_getAnimationAtIdx00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::AnimationManager* self = (const CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  unsigned int index = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAnimationAtIdx'",NULL);
#endif
 try
 {
  CEGUI::Animation* tolua_ret = (CEGUI::Animation*)  self->getAnimationAtIdx(index);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Animation");
 }
catch(CEGUI::InvalidRequestException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAnimationAtIdx'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNumAnimations of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_getNumAnimations00
static int tolua_CEGUI_CEGUI_AnimationManager_getNumAnimations00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::AnimationManager* self = (const CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNumAnimations'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getNumAnimations();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNumAnimations'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: instantiateAnimation of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_instantiateAnimation00
static int tolua_CEGUI_CEGUI_AnimationManager_instantiateAnimation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationManager* self = (CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Animation* animation = ((CEGUI::Animation*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'instantiateAnimation'",NULL);
#endif
 try
 {
  CEGUI::AnimationInstance* tolua_ret = (CEGUI::AnimationInstance*)  self->instantiateAnimation(animation);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::AnimationInstance");
 }
catch(CEGUI::UnknownObjectException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'instantiateAnimation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: instantiateAnimation of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_instantiateAnimation01
static int tolua_CEGUI_CEGUI_AnimationManager_instantiateAnimation01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::AnimationManager* self = (CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'instantiateAnimation'",NULL);
#endif
 try
 {
  CEGUI::AnimationInstance* tolua_ret = (CEGUI::AnimationInstance*)  self->instantiateAnimation(name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::AnimationInstance");
 }
catch(CEGUI::UnknownObjectException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_AnimationManager_instantiateAnimation00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyAnimationInstance of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_destroyAnimationInstance00
static int tolua_CEGUI_CEGUI_AnimationManager_destroyAnimationInstance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::AnimationInstance",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationManager* self = (CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::AnimationInstance* instance = ((CEGUI::AnimationInstance*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyAnimationInstance'",NULL);
#endif
 try
 {
  self->destroyAnimationInstance(instance);
 }
catch(CEGUI::InvalidRequestException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyAnimationInstance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyAllInstancesOfAnimation of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_destroyAllInstancesOfAnimation00
static int tolua_CEGUI_CEGUI_AnimationManager_destroyAllInstancesOfAnimation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Animation",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationManager* self = (CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Animation* animation = ((CEGUI::Animation*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyAllInstancesOfAnimation'",NULL);
#endif
 {
  self->destroyAllInstancesOfAnimation(animation);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyAllInstancesOfAnimation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAnimationInstanceAtIdx of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_getAnimationInstanceAtIdx00
static int tolua_CEGUI_CEGUI_AnimationManager_getAnimationInstanceAtIdx00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::AnimationManager* self = (const CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  unsigned int index = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAnimationInstanceAtIdx'",NULL);
#endif
 try
 {
  CEGUI::AnimationInstance* tolua_ret = (CEGUI::AnimationInstance*)  self->getAnimationInstanceAtIdx(index);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::AnimationInstance");
 }
catch(CEGUI::InvalidRequestException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAnimationInstanceAtIdx'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNumAnimationInstances of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_getNumAnimationInstances00
static int tolua_CEGUI_CEGUI_AnimationManager_getNumAnimationInstances00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::AnimationManager* self = (const CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNumAnimationInstances'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getNumAnimationInstances();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNumAnimationInstances'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stepInstances of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_stepInstances00
static int tolua_CEGUI_CEGUI_AnimationManager_stepInstances00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationManager* self = (CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  float delta = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'stepInstances'",NULL);
#endif
 {
  self->stepInstances(delta);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stepInstances'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: loadAnimationsFromXML of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_loadAnimationsFromXML00
static int tolua_CEGUI_CEGUI_AnimationManager_loadAnimationsFromXML00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AnimationManager* self = (CEGUI::AnimationManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string filename = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string resourceGroup = ((utf8string)  tolua_toutf8string(tolua_S,3,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadAnimationsFromXML'",NULL);
#endif
 {
  self->loadAnimationsFromXML(filename,resourceGroup);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadAnimationsFromXML'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDefaultResourceGroup of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_setDefaultResourceGroup00
static int tolua_CEGUI_CEGUI_AnimationManager_setDefaultResourceGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string resourceGroup = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::AnimationManager::setDefaultResourceGroup(resourceGroup);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDefaultResourceGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultResourceGroup of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_getDefaultResourceGroup00
static int tolua_CEGUI_CEGUI_AnimationManager_getDefaultResourceGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  string tolua_ret = (string)  CEGUI::AnimationManager::getDefaultResourceGroup();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultResourceGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getType of class  CEGUI::Interpolator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Interpolator_getType00
static int tolua_CEGUI_CEGUI_Interpolator_getType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Interpolator",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Interpolator* self = (const CEGUI::Interpolator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getType'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getType();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: interpolateAbsolute of class  CEGUI::Interpolator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Interpolator_interpolateAbsolute00
static int tolua_CEGUI_CEGUI_Interpolator_interpolateAbsolute00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Interpolator",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Interpolator* self = (CEGUI::Interpolator*)  tolua_tousertype(tolua_S,1,0);
  utf8string value1 = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string value2 = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  float position = ((float)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'interpolateAbsolute'",NULL);
#endif
 {
  string tolua_ret = (string)  self->interpolateAbsolute(value1,value2,position);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'interpolateAbsolute'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: interpolateRelative of class  CEGUI::Interpolator */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Interpolator_interpolateRelative00
static int tolua_CEGUI_CEGUI_Interpolator_interpolateRelative00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Interpolator",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Interpolator* self = (CEGUI::Interpolator*)  tolua_tousertype(tolua_S,1,0);
  utf8string base = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string value1 = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  utf8string value2 = ((utf8string)  tolua_toutf8string(tolua_S,4,0));
  float position = ((float)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'interpolateRelative'",NULL);
#endif
 {
  string tolua_ret = (string)  self->interpolateRelative(base,value1,value2,position);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'interpolateRelative'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemCount of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_getItemCount00
static int tolua_CEGUI_CEGUI_Tree_getItemCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Tree",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Tree* self = (const CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemCount'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getItemCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectedCount of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_getSelectedCount00
static int tolua_CEGUI_CEGUI_Tree_getSelectedCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Tree",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Tree* self = (const CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectedCount'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getSelectedCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectedCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFirstSelectedItem of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_getFirstSelectedItem00
static int tolua_CEGUI_CEGUI_Tree_getFirstSelectedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Tree",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Tree* self = (const CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFirstSelectedItem'",NULL);
#endif
 {
  CEGUI::TreeItem* tolua_ret = (CEGUI::TreeItem*)  self->getFirstSelectedItem();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TreeItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFirstSelectedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLastSelectedItem of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_getLastSelectedItem00
static int tolua_CEGUI_CEGUI_Tree_getLastSelectedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Tree",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Tree* self = (const CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLastSelectedItem'",NULL);
#endif
 {
  CEGUI::TreeItem* tolua_ret = (CEGUI::TreeItem*)  self->getLastSelectedItem();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TreeItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLastSelectedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: findFirstItemWithText of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_findFirstItemWithText00
static int tolua_CEGUI_CEGUI_Tree_findFirstItemWithText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findFirstItemWithText'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::TreeItem* tolua_ret = (CEGUI::TreeItem*)  self->findFirstItemWithText(text);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TreeItem");
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'findFirstItemWithText'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 catch(std::exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'std::exception' was thrown by function 'findFirstItemWithText'\nMessage: %s",e.what());
 errorDoIt = true;
}
 catch(...)
{
 snprintf(errorBuffer,512,"Unknown exception thrown by function 'findFirstItemWithText'");
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findFirstItemWithText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findNextItemWithText of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_findNextItemWithText00
static int tolua_CEGUI_CEGUI_Tree_findNextItemWithText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  const CEGUI::TreeItem* start_item = ((const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findNextItemWithText'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::TreeItem* tolua_ret = (CEGUI::TreeItem*)  self->findNextItemWithText(text,start_item);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TreeItem");
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'findNextItemWithText'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 catch(std::exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'std::exception' was thrown by function 'findNextItemWithText'\nMessage: %s",e.what());
 errorDoIt = true;
}
 catch(...)
{
 snprintf(errorBuffer,512,"Unknown exception thrown by function 'findNextItemWithText'");
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findNextItemWithText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findFirstItemWithID of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_findFirstItemWithID00
static int tolua_CEGUI_CEGUI_Tree_findFirstItemWithID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
  unsigned int searchID = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findFirstItemWithID'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::TreeItem* tolua_ret = (CEGUI::TreeItem*)  self->findFirstItemWithID(searchID);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TreeItem");
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'findFirstItemWithID'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 catch(std::exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'std::exception' was thrown by function 'findFirstItemWithID'\nMessage: %s",e.what());
 errorDoIt = true;
}
 catch(...)
{
 snprintf(errorBuffer,512,"Unknown exception thrown by function 'findFirstItemWithID'");
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findFirstItemWithID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findNextItemWithID of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_findNextItemWithID00
static int tolua_CEGUI_CEGUI_Tree_findNextItemWithID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
  unsigned int searchID = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  const CEGUI::TreeItem* start_item = ((const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findNextItemWithID'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::TreeItem* tolua_ret = (CEGUI::TreeItem*)  self->findNextItemWithID(searchID,start_item);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TreeItem");
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'findNextItemWithID'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 catch(std::exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'std::exception' was thrown by function 'findNextItemWithID'\nMessage: %s",e.what());
 errorDoIt = true;
}
 catch(...)
{
 snprintf(errorBuffer,512,"Unknown exception thrown by function 'findNextItemWithID'");
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findNextItemWithID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isTreeItemInList of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_isTreeItemInList00
static int tolua_CEGUI_CEGUI_Tree_isTreeItemInList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Tree",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Tree* self = (const CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::TreeItem* item = ((const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isTreeItemInList'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isTreeItemInList(item);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isTreeItemInList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resetList of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_resetList00
static int tolua_CEGUI_CEGUI_Tree_resetList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resetList'",NULL);
#endif
 {
  self->resetList();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resetList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addItem of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_addItem00
static int tolua_CEGUI_CEGUI_Tree_addItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::TreeItem* item = ((CEGUI::TreeItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addItem'",NULL);
#endif
 {
  self->addItem(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insertItem of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_insertItem00
static int tolua_CEGUI_CEGUI_Tree_insertItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::TreeItem* item = ((CEGUI::TreeItem*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::TreeItem* position = ((const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insertItem'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->insertItem(item,position);
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'insertItem'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 catch(std::exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'std::exception' was thrown by function 'insertItem'\nMessage: %s",e.what());
 errorDoIt = true;
}
 catch(...)
{
 snprintf(errorBuffer,512,"Unknown exception thrown by function 'insertItem'");
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'insertItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeItem of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_removeItem00
static int tolua_CEGUI_CEGUI_Tree_removeItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::TreeItem* item = ((const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeItem'",NULL);
#endif
 {
  self->removeItem(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearAllSelections of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_clearAllSelections00
static int tolua_CEGUI_CEGUI_Tree_clearAllSelections00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearAllSelections'",NULL);
#endif
 {
  self->clearAllSelections();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearAllSelections'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortingEnabled of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_setSortingEnabled00
static int tolua_CEGUI_CEGUI_Tree_setSortingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortingEnabled'",NULL);
#endif
 {
  self->setSortingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMultiselectEnabled of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_setMultiselectEnabled00
static int tolua_CEGUI_CEGUI_Tree_setMultiselectEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMultiselectEnabled'",NULL);
#endif
 {
  self->setMultiselectEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMultiselectEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setItemSelectState of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_setItemSelectState00
static int tolua_CEGUI_CEGUI_Tree_setItemSelectState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::TreeItem* item = ((CEGUI::TreeItem*)  tolua_tousertype(tolua_S,2,0));
  bool state = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setItemSelectState'",NULL);
#endif
 {
  self->setItemSelectState(item,state);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setItemSelectState'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setItemSelectState of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_setItemSelectState01
static int tolua_CEGUI_CEGUI_Tree_setItemSelectState01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
  unsigned long item_index = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  bool state = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setItemSelectState'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->setItemSelectState(item_index,state);
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'setItemSelectState'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 catch(std::exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'std::exception' was thrown by function 'setItemSelectState'\nMessage: %s",e.what());
 errorDoIt = true;
}
 catch(...)
{
 snprintf(errorBuffer,512,"Unknown exception thrown by function 'setItemSelectState'");
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Tree_setItemSelectState00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: ensureItemIsVisible of class  CEGUI::Tree */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tree_ensureItemIsVisible00
static int tolua_CEGUI_CEGUI_Tree_ensureItemIsVisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tree",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tree* self = (CEGUI::Tree*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::TreeItem* item = ((const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ensureItemIsVisible'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->ensureItemIsVisible(item);
 }
catch(CEGUI::Exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::Exception' was thrown by function 'ensureItemIsVisible'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 catch(std::exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'std::exception' was thrown by function 'ensureItemIsVisible'\nMessage: %s",e.what());
 errorDoIt = true;
}
 catch(...)
{
 snprintf(errorBuffer,512,"Unknown exception thrown by function 'ensureItemIsVisible'");
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ensureItemIsVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: setSelected of class  CEGUI::Checkbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Checkbox_setSelected00
static int tolua_CEGUI_CEGUI_Checkbox_setSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Checkbox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Checkbox* self = (CEGUI::Checkbox*)  tolua_tousertype(tolua_S,1,0);
  bool select = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelected'",NULL);
#endif
 {
  self->setSelected(select);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: setHotTracked of class  CEGUI::Thumb */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Thumb_setHotTracked00
static int tolua_CEGUI_CEGUI_Thumb_setHotTracked00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Thumb",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Thumb* self = (CEGUI::Thumb*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHotTracked'",NULL);
#endif
 {
  self->setHotTracked(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHotTracked'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVertFree of class  CEGUI::Thumb */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Thumb_setVertFree00
static int tolua_CEGUI_CEGUI_Thumb_setVertFree00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Thumb",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Thumb* self = (CEGUI::Thumb*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVertFree'",NULL);
#endif
 {
  self->setVertFree(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVertFree'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHorzFree of class  CEGUI::Thumb */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Thumb_setHorzFree00
static int tolua_CEGUI_CEGUI_Thumb_setHorzFree00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Thumb",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Thumb* self = (CEGUI::Thumb*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHorzFree'",NULL);
#endif
 {
  self->setHorzFree(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHorzFree'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ceguiLua_Thumb_getVertRange of class  CEGUI::Thumb */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Thumb_getVertRange00
static int tolua_CEGUI_CEGUI_Thumb_getVertRange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Thumb",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Thumb* self = (CEGUI::Thumb*)  tolua_tousertype(tolua_S,1,0);
  float min = ((float)  tolua_tonumber(tolua_S,2,0));
  float max = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ceguiLua_Thumb_getVertRange'",NULL);
#endif
 {
  ceguiLua_Thumb_getVertRange(self,&min,&max);
 tolua_pushnumber(tolua_S,(lua_Number)min);
 tolua_pushnumber(tolua_S,(lua_Number)max);
 }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVertRange'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ceguiLua_Thumb_getHorzRange of class  CEGUI::Thumb */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Thumb_getHorzRange00
static int tolua_CEGUI_CEGUI_Thumb_getHorzRange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Thumb",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Thumb* self = (CEGUI::Thumb*)  tolua_tousertype(tolua_S,1,0);
  float min = ((float)  tolua_tonumber(tolua_S,2,0));
  float max = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ceguiLua_Thumb_getHorzRange'",NULL);
#endif
 {
  ceguiLua_Thumb_getHorzRange(self,&min,&max);
 tolua_pushnumber(tolua_S,(lua_Number)min);
 tolua_pushnumber(tolua_S,(lua_Number)max);
 }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorzRange'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVertRange of class  CEGUI::Thumb */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Thumb_setVertRange00
static int tolua_CEGUI_CEGUI_Thumb_setVertRange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Thumb",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Thumb* self = (CEGUI::Thumb*)  tolua_tousertype(tolua_S,1,0);
  float min = ((float)  tolua_tonumber(tolua_S,2,0));
  float max = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVertRange'",NULL);
#endif
 {
  self->setVertRange(min,max);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVertRange'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHorzRange of class  CEGUI::Thumb */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Thumb_setHorzRange00
static int tolua_CEGUI_CEGUI_Thumb_setHorzRange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Thumb",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Thumb* self = (CEGUI::Thumb*)  tolua_tousertype(tolua_S,1,0);
  float min = ((float)  tolua_tonumber(tolua_S,2,0));
  float max = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHorzRange'",NULL);
#endif
 {
  self->setHorzRange(min,max);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHorzRange'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setSelected of class  CEGUI::RadioButton */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RadioButton_setSelected00
static int tolua_CEGUI_CEGUI_RadioButton_setSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RadioButton",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RadioButton* self = (CEGUI::RadioButton*)  tolua_tousertype(tolua_S,1,0);
  bool select = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelected'",NULL);
#endif
 {
  self->setSelected(select);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getGroupID of class  CEGUI::RadioButton */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RadioButton_getGroupID00
static int tolua_CEGUI_CEGUI_RadioButton_getGroupID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RadioButton",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::RadioButton* self = (const CEGUI::RadioButton*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getGroupID'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getGroupID();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getGroupID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setGroupID of class  CEGUI::RadioButton */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RadioButton_setGroupID00
static int tolua_CEGUI_CEGUI_RadioButton_setGroupID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RadioButton",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RadioButton* self = (CEGUI::RadioButton*)  tolua_tousertype(tolua_S,1,0);
  unsigned long group = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setGroupID'",NULL);
#endif
 {
  self->setGroupID(group);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setGroupID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectedButtonInGroup of class  CEGUI::RadioButton */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RadioButton_getSelectedButtonInGroup00
static int tolua_CEGUI_CEGUI_RadioButton_getSelectedButtonInGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RadioButton",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::RadioButton* self = (const CEGUI::RadioButton*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectedButtonInGroup'",NULL);
#endif
 {
  CEGUI::RadioButton* tolua_ret = (CEGUI::RadioButton*)  self->getSelectedButtonInGroup();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::RadioButton");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectedButtonInGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setSelected of class  CEGUI::TabButton */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabButton_setSelected00
static int tolua_CEGUI_CEGUI_TabButton_setSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TabButton",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TabButton* self = (CEGUI::TabButton*)  tolua_tousertype(tolua_S,1,0);
  bool select = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelected'",NULL);
#endif
 {
  self->setSelected(select);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTargetWindow of class  CEGUI::TabButton */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabButton_setTargetWindow00
static int tolua_CEGUI_CEGUI_TabButton_setTargetWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TabButton",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TabButton* self = (CEGUI::TabButton*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTargetWindow'",NULL);
#endif
 {
  self->setTargetWindow(wnd);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTargetWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTargetWindow of class  CEGUI::TabButton */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabButton_getTargetWindow00
static int tolua_CEGUI_CEGUI_TabButton_getTargetWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TabButton",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TabButton* self = (CEGUI::TabButton*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTargetWindow'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getTargetWindow();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTargetWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTabCount of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_getTabCount00
static int tolua_CEGUI_CEGUI_TabControl_getTabCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TabControl* self = (const CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTabCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getTabCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTabCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectedTab of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_setSelectedTab00
static int tolua_CEGUI_CEGUI_TabControl_setSelectedTab00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TabControl* self = (CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectedTab'",NULL);
#endif
 {
  self->setSelectedTab(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelectedTab'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectedTab of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_setSelectedTab01
static int tolua_CEGUI_CEGUI_TabControl_setSelectedTab01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::TabControl* self = (CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
  unsigned int ID = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectedTab'",NULL);
#endif
 {
  self->setSelectedTab(ID);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_TabControl_setSelectedTab00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectedTabAtIndex of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_setSelectedTabAtIndex00
static int tolua_CEGUI_CEGUI_TabControl_setSelectedTabAtIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TabControl* self = (CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
  unsigned int index = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectedTabAtIndex'",NULL);
#endif
 {
  self->setSelectedTabAtIndex(index);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelectedTabAtIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTabContentsAtIndex of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_getTabContentsAtIndex00
static int tolua_CEGUI_CEGUI_TabControl_getTabContentsAtIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TabControl* self = (const CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
  unsigned int index = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTabContentsAtIndex'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getTabContentsAtIndex(index);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTabContentsAtIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTabContents of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_getTabContents00
static int tolua_CEGUI_CEGUI_TabControl_getTabContents00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TabControl* self = (const CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTabContents'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getTabContents(name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTabContents'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTabContents of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_getTabContents01
static int tolua_CEGUI_CEGUI_TabControl_getTabContents01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::TabControl* self = (const CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
  unsigned int ID = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTabContents'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getTabContents(ID);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_TabControl_getTabContents00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: isTabContentsSelected of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_isTabContentsSelected00
static int tolua_CEGUI_CEGUI_TabControl_isTabContentsSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TabControl* self = (const CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isTabContentsSelected'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isTabContentsSelected(wnd);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isTabContentsSelected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectedTabIndex of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_getSelectedTabIndex00
static int tolua_CEGUI_CEGUI_TabControl_getSelectedTabIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TabControl* self = (const CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectedTabIndex'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getSelectedTabIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectedTabIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTabHeight of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_getTabHeight00
static int tolua_CEGUI_CEGUI_TabControl_getTabHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TabControl* self = (const CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTabHeight'",NULL);
#endif
 {
  const CEGUI::UDim& tolua_ret = (const CEGUI::UDim&)  self->getTabHeight();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::UDim");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTabHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTabTextPadding of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_getTabTextPadding00
static int tolua_CEGUI_CEGUI_TabControl_getTabTextPadding00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TabControl* self = (const CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTabTextPadding'",NULL);
#endif
 {
  const CEGUI::UDim& tolua_ret = (const CEGUI::UDim&)  self->getTabTextPadding();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::UDim");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTabTextPadding'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTabHeight of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_setTabHeight00
static int tolua_CEGUI_CEGUI_TabControl_setTabHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TabControl* self = (CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* height = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTabHeight'",NULL);
#endif
 {
  self->setTabHeight(*height);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTabHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTabTextPadding of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_setTabTextPadding00
static int tolua_CEGUI_CEGUI_TabControl_setTabTextPadding00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TabControl* self = (CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* pad = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTabTextPadding'",NULL);
#endif
 {
  self->setTabTextPadding(*pad);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTabTextPadding'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addTab of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_addTab00
static int tolua_CEGUI_CEGUI_TabControl_addTab00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TabControl* self = (CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addTab'",NULL);
#endif
 {
  self->addTab(wnd);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addTab'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeTab of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_removeTab00
static int tolua_CEGUI_CEGUI_TabControl_removeTab00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TabControl* self = (CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
  unsigned int ID = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeTab'",NULL);
#endif
 {
  self->removeTab(ID);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeTab'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeTab of class  CEGUI::TabControl */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TabControl_removeTab01
static int tolua_CEGUI_CEGUI_TabControl_removeTab01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TabControl",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::TabControl* self = (CEGUI::TabControl*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeTab'",NULL);
#endif
 {
  self->removeTab(name);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_TabControl_removeTab00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setDraggingEnabled of class  CEGUI::Titlebar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Titlebar_setDraggingEnabled00
static int tolua_CEGUI_CEGUI_Titlebar_setDraggingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Titlebar",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Titlebar* self = (CEGUI::Titlebar*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDraggingEnabled'",NULL);
#endif
 {
  self->setDraggingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDraggingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFont of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_getFont00
static int tolua_CEGUI_CEGUI_TreeItem_getFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TreeItem* self = (const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFont'",NULL);
#endif
 {
  CEGUI::Font* tolua_ret = (CEGUI::Font*)  self->getFont();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Font");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFont'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTextColours of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_getTextColours00
static int tolua_CEGUI_CEGUI_TreeItem_getTextColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TreeItem* self = (const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTextColours'",NULL);
#endif
 {
  CEGUI::ColourRect tolua_ret = (CEGUI::ColourRect)  self->getTextColours();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::ColourRect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ColourRect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::ColourRect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ColourRect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTextColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFont of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setFont00
static int tolua_CEGUI_CEGUI_TreeItem_setFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Font",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Font* font = ((CEGUI::Font*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFont'",NULL);
#endif
 {
  self->setFont(font);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFont'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFont of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setFont01
static int tolua_CEGUI_CEGUI_TreeItem_setFont01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  utf8string font_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFont'",NULL);
#endif
 {
  self->setFont(font_name);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_TreeItem_setFont00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTextColours of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setTextColours00
static int tolua_CEGUI_CEGUI_TreeItem_setTextColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ColourRect* cols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTextColours'",NULL);
#endif
 {
  self->setTextColours(*cols);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTextColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTextColours of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setTextColours01
static int tolua_CEGUI_CEGUI_TreeItem_setTextColours01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::colour top_left_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::colour top_right_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::colour bottom_left_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::colour bottom_right_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTextColours'",NULL);
#endif
 {
  self->setTextColours(top_left_colour,top_right_colour,bottom_left_colour,bottom_right_colour);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_TreeItem_setTextColours00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTextColours of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setTextColours02
static int tolua_CEGUI_CEGUI_TreeItem_setTextColours02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::colour col = *((CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTextColours'",NULL);
#endif
 {
  self->setTextColours(col);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_TreeItem_setTextColours01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getText of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_getText00
static int tolua_CEGUI_CEGUI_TreeItem_getText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TreeItem* self = (const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getText'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getText();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTooltipText of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_getTooltipText00
static int tolua_CEGUI_CEGUI_TreeItem_getTooltipText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TreeItem* self = (const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTooltipText'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getTooltipText();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTooltipText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getID of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_getID00
static int tolua_CEGUI_CEGUI_TreeItem_getID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TreeItem* self = (const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getID'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getID();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUserData of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_getUserData00
static int tolua_CEGUI_CEGUI_TreeItem_getUserData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TreeItem* self = (const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUserData'",NULL);
#endif
 {
  void* tolua_ret = (void*)  self->getUserData();
 tolua_pushuserdata(tolua_S,(void*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUserData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: getOwnerWindow of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_getOwnerWindow00
static int tolua_CEGUI_CEGUI_TreeItem_getOwnerWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOwnerWindow'",NULL);
#endif
 {
  const CEGUI::Window* tolua_ret = (const CEGUI::Window*)  self->getOwnerWindow();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOwnerWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionColours of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_getSelectionColours00
static int tolua_CEGUI_CEGUI_TreeItem_getSelectionColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TreeItem* self = (const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionColours'",NULL);
#endif
 {
  CEGUI::ColourRect tolua_ret = (CEGUI::ColourRect)  self->getSelectionColours();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::ColourRect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ColourRect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::ColourRect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ColourRect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionBrushImage of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_getSelectionBrushImage00
static int tolua_CEGUI_CEGUI_TreeItem_getSelectionBrushImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TreeItem* self = (const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionBrushImage'",NULL);
#endif
 {
  const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getSelectionBrushImage();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionBrushImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setText of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setText00
static int tolua_CEGUI_CEGUI_TreeItem_setText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setText'",NULL);
#endif
 {
  self->setText(text);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTooltipText of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setTooltipText00
static int tolua_CEGUI_CEGUI_TreeItem_setTooltipText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTooltipText'",NULL);
#endif
 {
  self->setTooltipText(text);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTooltipText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setID of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setID00
static int tolua_CEGUI_CEGUI_TreeItem_setID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  unsigned int item_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setID'",NULL);
#endif
 {
  self->setID(item_id);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUserData of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setUserData00
static int tolua_CEGUI_CEGUI_TreeItem_setUserData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  void* item_data = ((void*)  tolua_touserdata(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUserData'",NULL);
#endif
 {
  self->setUserData(item_data);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUserData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelected of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setSelected00
static int tolua_CEGUI_CEGUI_TreeItem_setSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelected'",NULL);
#endif
 {
  self->setSelected(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDisabled of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setDisabled00
static int tolua_CEGUI_CEGUI_TreeItem_setDisabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDisabled'",NULL);
#endif
 {
  self->setDisabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDisabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAutoDeleted of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setAutoDeleted00
static int tolua_CEGUI_CEGUI_TreeItem_setAutoDeleted00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoDeleted'",NULL);
#endif
 {
  self->setAutoDeleted(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoDeleted'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setOwnerWindow of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setOwnerWindow00
static int tolua_CEGUI_CEGUI_TreeItem_setOwnerWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* owner = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOwnerWindow'",NULL);
#endif
 {
  self->setOwnerWindow(owner);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setOwnerWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectionColours of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setSelectionColours00
static int tolua_CEGUI_CEGUI_TreeItem_setSelectionColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ColourRect* cols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectionColours'",NULL);
#endif
 {
  self->setSelectionColours(*cols);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelectionColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectionColours of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setSelectionColours01
static int tolua_CEGUI_CEGUI_TreeItem_setSelectionColours01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::colour top_left_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::colour top_right_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::colour bottom_left_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::colour bottom_right_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectionColours'",NULL);
#endif
 {
  self->setSelectionColours(top_left_colour,top_right_colour,bottom_left_colour,bottom_right_colour);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_TreeItem_setSelectionColours00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectionColours of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setSelectionColours02
static int tolua_CEGUI_CEGUI_TreeItem_setSelectionColours02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::colour col = *((CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectionColours'",NULL);
#endif
 {
  self->setSelectionColours(col);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_TreeItem_setSelectionColours01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectionBrushImage of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setSelectionBrushImage00
static int tolua_CEGUI_CEGUI_TreeItem_setSelectionBrushImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Image* image = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectionBrushImage'",NULL);
#endif
 {
  self->setSelectionBrushImage(image);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelectionBrushImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectionBrushImage of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setSelectionBrushImage01
static int tolua_CEGUI_CEGUI_TreeItem_setSelectionBrushImage01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  utf8string imageset = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string image = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectionBrushImage'",NULL);
#endif
 {
  self->setSelectionBrushImage(imageset,image);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_TreeItem_setSelectionBrushImage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setButtonLocation of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setButtonLocation00
static int tolua_CEGUI_CEGUI_TreeItem_setButtonLocation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Rect* buttonOffset = ((CEGUI::Rect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setButtonLocation'",NULL);
#endif
 {
  self->setButtonLocation(*buttonOffset);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setButtonLocation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getButtonLocation of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_getButtonLocation00
static int tolua_CEGUI_CEGUI_TreeItem_getButtonLocation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getButtonLocation'",NULL);
#endif
 {
  CEGUI::Rect& tolua_ret = (CEGUI::Rect&)  self->getButtonLocation();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Rect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getButtonLocation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: toggleIsOpen of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_toggleIsOpen00
static int tolua_CEGUI_CEGUI_TreeItem_toggleIsOpen00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toggleIsOpen'",NULL);
#endif
 {
  self->toggleIsOpen();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toggleIsOpen'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTreeItemFromIndex of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_getTreeItemFromIndex00
static int tolua_CEGUI_CEGUI_TreeItem_getTreeItemFromIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  unsigned long itemIndex = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTreeItemFromIndex'",NULL);
#endif
 {
  CEGUI::TreeItem* tolua_ret = (CEGUI::TreeItem*)  self->getTreeItemFromIndex(itemIndex);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TreeItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTreeItemFromIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemCount of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_getItemCount00
static int tolua_CEGUI_CEGUI_TreeItem_getItemCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TreeItem* self = (const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemCount'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getItemCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addItem of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_addItem00
static int tolua_CEGUI_CEGUI_TreeItem_addItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::TreeItem* item = ((CEGUI::TreeItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addItem'",NULL);
#endif
 {
  self->addItem(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeItem of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_removeItem00
static int tolua_CEGUI_CEGUI_TreeItem_removeItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::TreeItem* item = ((const CEGUI::TreeItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeItem'",NULL);
#endif
 {
  self->removeItem(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setIcon of class  CEGUI::TreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TreeItem_setIcon00
static int tolua_CEGUI_CEGUI_TreeItem_setIcon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TreeItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Image* theIcon = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setIcon'",NULL);
#endif
 {
  self->setIcon(*theIcon);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setIcon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

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

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

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

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

/* method: setSizingEnabled of class  CEGUI::FrameWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameWindow_setSizingEnabled00
static int tolua_CEGUI_CEGUI_FrameWindow_setSizingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameWindow",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FrameWindow* self = (CEGUI::FrameWindow*)  tolua_tousertype(tolua_S,1,0);
  bool enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSizingEnabled'",NULL);
#endif
 {
  self->setSizingEnabled(enabled);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSizingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFrameEnabled of class  CEGUI::FrameWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameWindow_setFrameEnabled00
static int tolua_CEGUI_CEGUI_FrameWindow_setFrameEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameWindow",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FrameWindow* self = (CEGUI::FrameWindow*)  tolua_tousertype(tolua_S,1,0);
  bool enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFrameEnabled'",NULL);
#endif
 {
  self->setFrameEnabled(enabled);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFrameEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTitleBarEnabled of class  CEGUI::FrameWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameWindow_setTitleBarEnabled00
static int tolua_CEGUI_CEGUI_FrameWindow_setTitleBarEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameWindow",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FrameWindow* self = (CEGUI::FrameWindow*)  tolua_tousertype(tolua_S,1,0);
  bool enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTitleBarEnabled'",NULL);
#endif
 {
  self->setTitleBarEnabled(enabled);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTitleBarEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCloseButtonEnabled of class  CEGUI::FrameWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameWindow_setCloseButtonEnabled00
static int tolua_CEGUI_CEGUI_FrameWindow_setCloseButtonEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameWindow",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FrameWindow* self = (CEGUI::FrameWindow*)  tolua_tousertype(tolua_S,1,0);
  bool enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCloseButtonEnabled'",NULL);
#endif
 {
  self->setCloseButtonEnabled(enabled);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCloseButtonEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRollupEnabled of class  CEGUI::FrameWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameWindow_setRollupEnabled00
static int tolua_CEGUI_CEGUI_FrameWindow_setRollupEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameWindow",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FrameWindow* self = (CEGUI::FrameWindow*)  tolua_tousertype(tolua_S,1,0);
  bool enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRollupEnabled'",NULL);
#endif
 {
  self->setRollupEnabled(enabled);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRollupEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDragMovingEnabled of class  CEGUI::FrameWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameWindow_setDragMovingEnabled00
static int tolua_CEGUI_CEGUI_FrameWindow_setDragMovingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameWindow",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FrameWindow* self = (CEGUI::FrameWindow*)  tolua_tousertype(tolua_S,1,0);
  bool enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDragMovingEnabled'",NULL);
#endif
 {
  self->setDragMovingEnabled(enabled);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDragMovingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSizingBorderThickness of class  CEGUI::FrameWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameWindow_getSizingBorderThickness00
static int tolua_CEGUI_CEGUI_FrameWindow_getSizingBorderThickness00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FrameWindow",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FrameWindow* self = (const CEGUI::FrameWindow*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSizingBorderThickness'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getSizingBorderThickness();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSizingBorderThickness'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSizingBorderThickness of class  CEGUI::FrameWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameWindow_setSizingBorderThickness00
static int tolua_CEGUI_CEGUI_FrameWindow_setSizingBorderThickness00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameWindow",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FrameWindow* self = (CEGUI::FrameWindow*)  tolua_tousertype(tolua_S,1,0);
  float pixels = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSizingBorderThickness'",NULL);
#endif
 {
  self->setSizingBorderThickness(pixels);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSizingBorderThickness'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toggleRollup of class  CEGUI::FrameWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameWindow_toggleRollup00
static int tolua_CEGUI_CEGUI_FrameWindow_toggleRollup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameWindow",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FrameWindow* self = (CEGUI::FrameWindow*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toggleRollup'",NULL);
#endif
 {
  self->toggleRollup();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toggleRollup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: offsetPixelPosition of class  CEGUI::FrameWindow */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameWindow_offsetPixelPosition00
static int tolua_CEGUI_CEGUI_FrameWindow_offsetPixelPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameWindow",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FrameWindow* self = (CEGUI::FrameWindow*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* offset = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'offsetPixelPosition'",NULL);
#endif
 {
  self->offsetPixelPosition(*offset);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'offsetPixelPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTargetWindow of class  CEGUI::Tooltip */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tooltip_setTargetWindow00
static int tolua_CEGUI_CEGUI_Tooltip_setTargetWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tooltip",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tooltip* self = (CEGUI::Tooltip*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTargetWindow'",NULL);
#endif
 {
  self->setTargetWindow(wnd);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTargetWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resetTimer of class  CEGUI::Tooltip */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tooltip_resetTimer00
static int tolua_CEGUI_CEGUI_Tooltip_resetTimer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tooltip",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tooltip* self = (CEGUI::Tooltip*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resetTimer'",NULL);
#endif
 {
  self->resetTimer();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resetTimer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHoverTime of class  CEGUI::Tooltip */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tooltip_getHoverTime00
static int tolua_CEGUI_CEGUI_Tooltip_getHoverTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Tooltip",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Tooltip* self = (const CEGUI::Tooltip*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHoverTime'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getHoverTime();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHoverTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDisplayTime of class  CEGUI::Tooltip */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tooltip_setDisplayTime00
static int tolua_CEGUI_CEGUI_Tooltip_setDisplayTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tooltip",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tooltip* self = (CEGUI::Tooltip*)  tolua_tousertype(tolua_S,1,0);
  float seconds = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDisplayTime'",NULL);
#endif
 {
  self->setDisplayTime(seconds);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDisplayTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFadeTime of class  CEGUI::Tooltip */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tooltip_getFadeTime00
static int tolua_CEGUI_CEGUI_Tooltip_getFadeTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Tooltip",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Tooltip* self = (const CEGUI::Tooltip*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFadeTime'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getFadeTime();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFadeTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHoverTime of class  CEGUI::Tooltip */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tooltip_setHoverTime00
static int tolua_CEGUI_CEGUI_Tooltip_setHoverTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tooltip",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tooltip* self = (CEGUI::Tooltip*)  tolua_tousertype(tolua_S,1,0);
  float seconds = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHoverTime'",NULL);
#endif
 {
  self->setHoverTime(seconds);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHoverTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDisplayTime of class  CEGUI::Tooltip */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tooltip_getDisplayTime00
static int tolua_CEGUI_CEGUI_Tooltip_getDisplayTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Tooltip",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Tooltip* self = (const CEGUI::Tooltip*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDisplayTime'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getDisplayTime();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDisplayTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFadeTime of class  CEGUI::Tooltip */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tooltip_setFadeTime00
static int tolua_CEGUI_CEGUI_Tooltip_setFadeTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Tooltip",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Tooltip* self = (CEGUI::Tooltip*)  tolua_tousertype(tolua_S,1,0);
  float seconds = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFadeTime'",NULL);
#endif
 {
  self->setFadeTime(seconds);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFadeTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setDraggingEnabled of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_setDraggingEnabled00
static int tolua_CEGUI_CEGUI_DragContainer_setDraggingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::DragContainer* self = (CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDraggingEnabled'",NULL);
#endif
 {
  self->setDraggingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDraggingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getPixelDragThreshold of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_getPixelDragThreshold00
static int tolua_CEGUI_CEGUI_DragContainer_getPixelDragThreshold00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::DragContainer* self = (const CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPixelDragThreshold'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getPixelDragThreshold();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPixelDragThreshold'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPixelDragThreshold of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_setPixelDragThreshold00
static int tolua_CEGUI_CEGUI_DragContainer_setPixelDragThreshold00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::DragContainer* self = (CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
  float pixels = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPixelDragThreshold'",NULL);
#endif
 {
  self->setPixelDragThreshold(pixels);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPixelDragThreshold'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDragAlpha of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_getDragAlpha00
static int tolua_CEGUI_CEGUI_DragContainer_getDragAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::DragContainer* self = (const CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDragAlpha'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getDragAlpha();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDragAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDragAlpha of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_setDragAlpha00
static int tolua_CEGUI_CEGUI_DragContainer_setDragAlpha00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::DragContainer* self = (CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
  float alpha = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDragAlpha'",NULL);
#endif
 {
  self->setDragAlpha(alpha);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDragAlpha'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDragCursorImage of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_getDragCursorImage00
static int tolua_CEGUI_CEGUI_DragContainer_getDragCursorImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::DragContainer* self = (const CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDragCursorImage'",NULL);
#endif
 {
  const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getDragCursorImage();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDragCursorImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDragCursorImage of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_setDragCursorImage00
static int tolua_CEGUI_CEGUI_DragContainer_setDragCursorImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::DragContainer* self = (CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MouseCursorImage image = ((CEGUI::MouseCursorImage) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDragCursorImage'",NULL);
#endif
 {
  self->setDragCursorImage(image);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDragCursorImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDragCursorImage of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_setDragCursorImage01
static int tolua_CEGUI_CEGUI_DragContainer_setDragCursorImage01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::DragContainer* self = (CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
  utf8string imageset = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string image = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDragCursorImage'",NULL);
#endif
 {
  self->setDragCursorImage(imageset,image);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_DragContainer_setDragCursorImage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDragCursorImage of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_setDragCursorImage02
static int tolua_CEGUI_CEGUI_DragContainer_setDragCursorImage02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::DragContainer* self = (CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Image* image = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDragCursorImage'",NULL);
#endif
 {
  self->setDragCursorImage(image);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_DragContainer_setDragCursorImage01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentDropTarget of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_getCurrentDropTarget00
static int tolua_CEGUI_CEGUI_DragContainer_getCurrentDropTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::DragContainer* self = (const CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentDropTarget'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getCurrentDropTarget();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCurrentDropTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setStickyModeEnabled of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_setStickyModeEnabled00
static int tolua_CEGUI_CEGUI_DragContainer_setStickyModeEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::DragContainer* self = (CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStickyModeEnabled'",NULL);
#endif
 {
  self->setStickyModeEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setStickyModeEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: pickUp of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_pickUp00
static int tolua_CEGUI_CEGUI_DragContainer_pickUp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::DragContainer* self = (CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
  bool force_sticky = ((bool)  tolua_toboolean(tolua_S,2,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pickUp'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->pickUp(force_sticky);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'pickUp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFixedDragOffset of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_setFixedDragOffset00
static int tolua_CEGUI_CEGUI_DragContainer_setFixedDragOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::DragContainer* self = (CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* offset = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFixedDragOffset'",NULL);
#endif
 {
  self->setFixedDragOffset(*offset);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFixedDragOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFixedDragOffset of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_getFixedDragOffset00
static int tolua_CEGUI_CEGUI_DragContainer_getFixedDragOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::DragContainer* self = (const CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFixedDragOffset'",NULL);
#endif
 {
  const CEGUI::UVector2& tolua_ret = (const CEGUI::UVector2&)  self->getFixedDragOffset();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::UVector2");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFixedDragOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUsingFixedDragOffset of class  CEGUI::DragContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_DragContainer_setUsingFixedDragOffset00
static int tolua_CEGUI_CEGUI_DragContainer_setUsingFixedDragOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::DragContainer",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::DragContainer* self = (CEGUI::DragContainer*)  tolua_tousertype(tolua_S,1,0);
  bool enable = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUsingFixedDragOffset'",NULL);
#endif
 {
  self->setUsingFixedDragOffset(enable);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUsingFixedDragOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getDocumentSize of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_getDocumentSize00
static int tolua_CEGUI_CEGUI_Scrollbar_getDocumentSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Scrollbar",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Scrollbar* self = (const CEGUI::Scrollbar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDocumentSize'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getDocumentSize();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDocumentSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPageSize of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_getPageSize00
static int tolua_CEGUI_CEGUI_Scrollbar_getPageSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Scrollbar",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Scrollbar* self = (const CEGUI::Scrollbar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPageSize'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getPageSize();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPageSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getStepSize of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_getStepSize00
static int tolua_CEGUI_CEGUI_Scrollbar_getStepSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Scrollbar",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Scrollbar* self = (const CEGUI::Scrollbar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getStepSize'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getStepSize();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getStepSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOverlapSize of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_getOverlapSize00
static int tolua_CEGUI_CEGUI_Scrollbar_getOverlapSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Scrollbar",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Scrollbar* self = (const CEGUI::Scrollbar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOverlapSize'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getOverlapSize();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOverlapSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getScrollPosition of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_getScrollPosition00
static int tolua_CEGUI_CEGUI_Scrollbar_getScrollPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Scrollbar",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Scrollbar* self = (const CEGUI::Scrollbar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getScrollPosition'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getScrollPosition();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getScrollPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setDocumentSize of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_setDocumentSize00
static int tolua_CEGUI_CEGUI_Scrollbar_setDocumentSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Scrollbar",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Scrollbar* self = (CEGUI::Scrollbar*)  tolua_tousertype(tolua_S,1,0);
  float document_size = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDocumentSize'",NULL);
#endif
 {
  self->setDocumentSize(document_size);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDocumentSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPageSize of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_setPageSize00
static int tolua_CEGUI_CEGUI_Scrollbar_setPageSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Scrollbar",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Scrollbar* self = (CEGUI::Scrollbar*)  tolua_tousertype(tolua_S,1,0);
  float page_size = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPageSize'",NULL);
#endif
 {
  self->setPageSize(page_size);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPageSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setStepSize of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_setStepSize00
static int tolua_CEGUI_CEGUI_Scrollbar_setStepSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Scrollbar",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Scrollbar* self = (CEGUI::Scrollbar*)  tolua_tousertype(tolua_S,1,0);
  float step_size = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStepSize'",NULL);
#endif
 {
  self->setStepSize(step_size);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setStepSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setOverlapSize of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_setOverlapSize00
static int tolua_CEGUI_CEGUI_Scrollbar_setOverlapSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Scrollbar",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Scrollbar* self = (CEGUI::Scrollbar*)  tolua_tousertype(tolua_S,1,0);
  float overlap_size = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOverlapSize'",NULL);
#endif
 {
  self->setOverlapSize(overlap_size);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setOverlapSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setScrollPosition of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_setScrollPosition00
static int tolua_CEGUI_CEGUI_Scrollbar_setScrollPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Scrollbar",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Scrollbar* self = (CEGUI::Scrollbar*)  tolua_tousertype(tolua_S,1,0);
  float position = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setScrollPosition'",NULL);
#endif
 {
  self->setScrollPosition(position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setScrollPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setEndLockEnabled of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_setEndLockEnabled00
static int tolua_CEGUI_CEGUI_Scrollbar_setEndLockEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Scrollbar",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Scrollbar* self = (CEGUI::Scrollbar*)  tolua_tousertype(tolua_S,1,0);
  bool enabled = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setEndLockEnabled'",NULL);
#endif
 {
  self->setEndLockEnabled(enabled);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setEndLockEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setContentPaneAutoSized of class  CEGUI::ScrolledContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrolledContainer_setContentPaneAutoSized00
static int tolua_CEGUI_CEGUI_ScrolledContainer_setContentPaneAutoSized00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrolledContainer",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrolledContainer* self = (CEGUI::ScrolledContainer*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setContentPaneAutoSized'",NULL);
#endif
 {
  self->setContentPaneAutoSized(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setContentPaneAutoSized'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getContentArea of class  CEGUI::ScrolledContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrolledContainer_getContentArea00
static int tolua_CEGUI_CEGUI_ScrolledContainer_getContentArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrolledContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrolledContainer* self = (const CEGUI::ScrolledContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getContentArea'",NULL);
#endif
 {
  const CEGUI::Rect& tolua_ret = (const CEGUI::Rect&)  self->getContentArea();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Rect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getContentArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setContentArea of class  CEGUI::ScrolledContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrolledContainer_setContentArea00
static int tolua_CEGUI_CEGUI_ScrolledContainer_setContentArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrolledContainer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrolledContainer* self = (CEGUI::ScrolledContainer*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Rect* area = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setContentArea'",NULL);
#endif
 {
  self->setContentArea(*area);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setContentArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildExtentsArea of class  CEGUI::ScrolledContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrolledContainer_getChildExtentsArea00
static int tolua_CEGUI_CEGUI_ScrolledContainer_getChildExtentsArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrolledContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrolledContainer* self = (const CEGUI::ScrolledContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getChildExtentsArea'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getChildExtentsArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getChildExtentsArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getContentPane of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_getContentPane00
static int tolua_CEGUI_CEGUI_ScrollablePane_getContentPane00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrollablePane* self = (const CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getContentPane'",NULL);
#endif
 {
  const CEGUI::ScrolledContainer* tolua_ret = (const CEGUI::ScrolledContainer*)  self->getContentPane();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::ScrolledContainer");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getContentPane'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setShowVertScrollbar of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_setShowVertScrollbar00
static int tolua_CEGUI_CEGUI_ScrollablePane_setShowVertScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrollablePane* self = (CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShowVertScrollbar'",NULL);
#endif
 {
  self->setShowVertScrollbar(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShowVertScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setShowHorzScrollbar of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_setShowHorzScrollbar00
static int tolua_CEGUI_CEGUI_ScrollablePane_setShowHorzScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrollablePane* self = (CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShowHorzScrollbar'",NULL);
#endif
 {
  self->setShowHorzScrollbar(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShowHorzScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setContentPaneAutoSized of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_setContentPaneAutoSized00
static int tolua_CEGUI_CEGUI_ScrollablePane_setContentPaneAutoSized00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrollablePane* self = (CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setContentPaneAutoSized'",NULL);
#endif
 {
  self->setContentPaneAutoSized(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setContentPaneAutoSized'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getContentPaneArea of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_getContentPaneArea00
static int tolua_CEGUI_CEGUI_ScrollablePane_getContentPaneArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrollablePane* self = (const CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getContentPaneArea'",NULL);
#endif
 {
  const CEGUI::Rect& tolua_ret = (const CEGUI::Rect&)  self->getContentPaneArea();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Rect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getContentPaneArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setContentPaneArea of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_setContentPaneArea00
static int tolua_CEGUI_CEGUI_ScrollablePane_setContentPaneArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrollablePane* self = (CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Rect* area = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setContentPaneArea'",NULL);
#endif
 {
  self->setContentPaneArea(*area);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setContentPaneArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHorizontalStepSize of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_getHorizontalStepSize00
static int tolua_CEGUI_CEGUI_ScrollablePane_getHorizontalStepSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrollablePane* self = (const CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHorizontalStepSize'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getHorizontalStepSize();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorizontalStepSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHorizontalStepSize of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_setHorizontalStepSize00
static int tolua_CEGUI_CEGUI_ScrollablePane_setHorizontalStepSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrollablePane* self = (CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
  float step = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHorizontalStepSize'",NULL);
#endif
 {
  self->setHorizontalStepSize(step);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHorizontalStepSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHorizontalOverlapSize of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_getHorizontalOverlapSize00
static int tolua_CEGUI_CEGUI_ScrollablePane_getHorizontalOverlapSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrollablePane* self = (const CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHorizontalOverlapSize'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getHorizontalOverlapSize();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorizontalOverlapSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHorizontalOverlapSize of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_setHorizontalOverlapSize00
static int tolua_CEGUI_CEGUI_ScrollablePane_setHorizontalOverlapSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrollablePane* self = (CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
  float overlap = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHorizontalOverlapSize'",NULL);
#endif
 {
  self->setHorizontalOverlapSize(overlap);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHorizontalOverlapSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHorizontalScrollPosition of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_getHorizontalScrollPosition00
static int tolua_CEGUI_CEGUI_ScrollablePane_getHorizontalScrollPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrollablePane* self = (const CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHorizontalScrollPosition'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getHorizontalScrollPosition();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorizontalScrollPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHorizontalScrollPosition of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_setHorizontalScrollPosition00
static int tolua_CEGUI_CEGUI_ScrollablePane_setHorizontalScrollPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrollablePane* self = (CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
  float position = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHorizontalScrollPosition'",NULL);
#endif
 {
  self->setHorizontalScrollPosition(position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHorizontalScrollPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVerticalStepSize of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_getVerticalStepSize00
static int tolua_CEGUI_CEGUI_ScrollablePane_getVerticalStepSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrollablePane* self = (const CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVerticalStepSize'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getVerticalStepSize();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVerticalStepSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVerticalStepSize of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_setVerticalStepSize00
static int tolua_CEGUI_CEGUI_ScrollablePane_setVerticalStepSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrollablePane* self = (CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
  float step = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVerticalStepSize'",NULL);
#endif
 {
  self->setVerticalStepSize(step);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVerticalStepSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVerticalOverlapSize of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_getVerticalOverlapSize00
static int tolua_CEGUI_CEGUI_ScrollablePane_getVerticalOverlapSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrollablePane* self = (const CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVerticalOverlapSize'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getVerticalOverlapSize();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVerticalOverlapSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVerticalOverlapSize of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_setVerticalOverlapSize00
static int tolua_CEGUI_CEGUI_ScrollablePane_setVerticalOverlapSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrollablePane* self = (CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
  float overlap = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVerticalOverlapSize'",NULL);
#endif
 {
  self->setVerticalOverlapSize(overlap);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVerticalOverlapSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVerticalScrollPosition of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_getVerticalScrollPosition00
static int tolua_CEGUI_CEGUI_ScrollablePane_getVerticalScrollPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrollablePane* self = (const CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVerticalScrollPosition'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getVerticalScrollPosition();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVerticalScrollPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVerticalScrollPosition of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_setVerticalScrollPosition00
static int tolua_CEGUI_CEGUI_ScrollablePane_setVerticalScrollPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrollablePane* self = (CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
  float position = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVerticalScrollPosition'",NULL);
#endif
 {
  self->setVerticalScrollPosition(position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVerticalScrollPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getViewableArea of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_getViewableArea00
static int tolua_CEGUI_CEGUI_ScrollablePane_getViewableArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrollablePane* self = (const CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getViewableArea'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getViewableArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getViewableArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVertScrollbar of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_getVertScrollbar00
static int tolua_CEGUI_CEGUI_ScrollablePane_getVertScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrollablePane* self = (const CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVertScrollbar'",NULL);
#endif
 {
  CEGUI::Scrollbar* tolua_ret = (CEGUI::Scrollbar*)  self->getVertScrollbar();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Scrollbar");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVertScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHorzScrollbar of class  CEGUI::ScrollablePane */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrollablePane_getHorzScrollbar00
static int tolua_CEGUI_CEGUI_ScrollablePane_getHorzScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrollablePane",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrollablePane* self = (const CEGUI::ScrollablePane*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHorzScrollbar'",NULL);
#endif
 {
  CEGUI::Scrollbar* tolua_ret = (CEGUI::Scrollbar*)  self->getHorzScrollbar();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Scrollbar");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorzScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentValue of class  CEGUI::Slider */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Slider_getCurrentValue00
static int tolua_CEGUI_CEGUI_Slider_getCurrentValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Slider",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Slider* self = (const CEGUI::Slider*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentValue'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getCurrentValue();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCurrentValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMaxValue of class  CEGUI::Slider */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Slider_getMaxValue00
static int tolua_CEGUI_CEGUI_Slider_getMaxValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Slider",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Slider* self = (const CEGUI::Slider*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMaxValue'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getMaxValue();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMaxValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getClickStep of class  CEGUI::Slider */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Slider_getClickStep00
static int tolua_CEGUI_CEGUI_Slider_getClickStep00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Slider",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Slider* self = (const CEGUI::Slider*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getClickStep'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getClickStep();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getClickStep'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMaxValue of class  CEGUI::Slider */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Slider_setMaxValue00
static int tolua_CEGUI_CEGUI_Slider_setMaxValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Slider",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Slider* self = (CEGUI::Slider*)  tolua_tousertype(tolua_S,1,0);
  float maxVal = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMaxValue'",NULL);
#endif
 {
  self->setMaxValue(maxVal);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMaxValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCurrentValue of class  CEGUI::Slider */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Slider_setCurrentValue00
static int tolua_CEGUI_CEGUI_Slider_setCurrentValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Slider",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Slider* self = (CEGUI::Slider*)  tolua_tousertype(tolua_S,1,0);
  float value = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCurrentValue'",NULL);
#endif
 {
  self->setCurrentValue(value);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCurrentValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setClickStep of class  CEGUI::Slider */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Slider_setClickStep00
static int tolua_CEGUI_CEGUI_Slider_setClickStep00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Slider",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Slider* self = (CEGUI::Slider*)  tolua_tousertype(tolua_S,1,0);
  float step = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setClickStep'",NULL);
#endif
 {
  self->setClickStep(step);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setClickStep'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCurrentValue of class  CEGUI::Spinner */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Spinner_getCurrentValue00
static int tolua_CEGUI_CEGUI_Spinner_getCurrentValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Spinner",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Spinner* self = (const CEGUI::Spinner*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCurrentValue'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getCurrentValue();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCurrentValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getStepSize of class  CEGUI::Spinner */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Spinner_getStepSize00
static int tolua_CEGUI_CEGUI_Spinner_getStepSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Spinner",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Spinner* self = (const CEGUI::Spinner*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getStepSize'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getStepSize();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getStepSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMaximumValue of class  CEGUI::Spinner */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Spinner_getMaximumValue00
static int tolua_CEGUI_CEGUI_Spinner_getMaximumValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Spinner",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Spinner* self = (const CEGUI::Spinner*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMaximumValue'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getMaximumValue();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMaximumValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMinimumValue of class  CEGUI::Spinner */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Spinner_getMinimumValue00
static int tolua_CEGUI_CEGUI_Spinner_getMinimumValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Spinner",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Spinner* self = (const CEGUI::Spinner*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMinimumValue'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getMinimumValue();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMinimumValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTextInputMode of class  CEGUI::Spinner */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Spinner_getTextInputMode00
static int tolua_CEGUI_CEGUI_Spinner_getTextInputMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Spinner",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Spinner* self = (const CEGUI::Spinner*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTextInputMode'",NULL);
#endif
 {
  CEGUI::Spinner::TextInputMode tolua_ret = (CEGUI::Spinner::TextInputMode)  self->getTextInputMode();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTextInputMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCurrentValue of class  CEGUI::Spinner */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Spinner_setCurrentValue00
static int tolua_CEGUI_CEGUI_Spinner_setCurrentValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Spinner",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Spinner* self = (CEGUI::Spinner*)  tolua_tousertype(tolua_S,1,0);
  float value = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCurrentValue'",NULL);
#endif
 {
  self->setCurrentValue(value);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCurrentValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setStepSize of class  CEGUI::Spinner */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Spinner_setStepSize00
static int tolua_CEGUI_CEGUI_Spinner_setStepSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Spinner",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Spinner* self = (CEGUI::Spinner*)  tolua_tousertype(tolua_S,1,0);
  float step = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStepSize'",NULL);
#endif
 {
  self->setStepSize(step);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setStepSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMaximumValue of class  CEGUI::Spinner */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Spinner_setMaximumValue00
static int tolua_CEGUI_CEGUI_Spinner_setMaximumValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Spinner",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Spinner* self = (CEGUI::Spinner*)  tolua_tousertype(tolua_S,1,0);
  float maxValue = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMaximumValue'",NULL);
#endif
 {
  self->setMaximumValue(maxValue);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMaximumValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMinimumValue of class  CEGUI::Spinner */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Spinner_setMinimumValue00
static int tolua_CEGUI_CEGUI_Spinner_setMinimumValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Spinner",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Spinner* self = (CEGUI::Spinner*)  tolua_tousertype(tolua_S,1,0);
  float minVaue = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMinimumValue'",NULL);
#endif
 {
  self->setMinimumValue(minVaue);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMinimumValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTextInputMode of class  CEGUI::Spinner */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Spinner_setTextInputMode00
static int tolua_CEGUI_CEGUI_Spinner_setTextInputMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Spinner",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Spinner* self = (CEGUI::Spinner*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Spinner::TextInputMode mode = ((CEGUI::Spinner::TextInputMode) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTextInputMode'",NULL);
#endif
 {
  self->setTextInputMode(mode);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTextInputMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getProgress of class  CEGUI::ProgressBar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ProgressBar_getProgress00
static int tolua_CEGUI_CEGUI_ProgressBar_getProgress00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ProgressBar",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ProgressBar* self = (const CEGUI::ProgressBar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getProgress'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getProgress();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getProgress'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getStep of class  CEGUI::ProgressBar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ProgressBar_getStep00
static int tolua_CEGUI_CEGUI_ProgressBar_getStep00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ProgressBar",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ProgressBar* self = (const CEGUI::ProgressBar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getStep'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getStep();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getStep'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setProgress of class  CEGUI::ProgressBar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ProgressBar_setProgress00
static int tolua_CEGUI_CEGUI_ProgressBar_setProgress00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ProgressBar",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ProgressBar* self = (CEGUI::ProgressBar*)  tolua_tousertype(tolua_S,1,0);
  float progress = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setProgress'",NULL);
#endif
 {
  self->setProgress(progress);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setProgress'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setStepSize of class  CEGUI::ProgressBar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ProgressBar_setStepSize00
static int tolua_CEGUI_CEGUI_ProgressBar_setStepSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ProgressBar",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ProgressBar* self = (CEGUI::ProgressBar*)  tolua_tousertype(tolua_S,1,0);
  float step = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStepSize'",NULL);
#endif
 {
  self->setStepSize(step);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setStepSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: step of class  CEGUI::ProgressBar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ProgressBar_step00
static int tolua_CEGUI_CEGUI_ProgressBar_step00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ProgressBar",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ProgressBar* self = (CEGUI::ProgressBar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'step'",NULL);
#endif
 {
  self->step();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'step'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: adjustProgress of class  CEGUI::ProgressBar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ProgressBar_adjustProgress00
static int tolua_CEGUI_CEGUI_ProgressBar_adjustProgress00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ProgressBar",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ProgressBar* self = (CEGUI::ProgressBar*)  tolua_tousertype(tolua_S,1,0);
  float delta = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'adjustProgress'",NULL);
#endif
 {
  self->adjustProgress(delta);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'adjustProgress'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

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

/* method: getValidationString of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_getValidationString00
static int tolua_CEGUI_CEGUI_Editbox_getValidationString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Editbox* self = (const CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValidationString'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getValidationString();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getValidationString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCaratIndex of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_getCaratIndex00
static int tolua_CEGUI_CEGUI_Editbox_getCaratIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Editbox* self = (const CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCaratIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getCaratIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCaratIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionStartIndex of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_getSelectionStartIndex00
static int tolua_CEGUI_CEGUI_Editbox_getSelectionStartIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Editbox* self = (const CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionStartIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getSelectionStartIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionStartIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionEndIndex of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_getSelectionEndIndex00
static int tolua_CEGUI_CEGUI_Editbox_getSelectionEndIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Editbox* self = (const CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionEndIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getSelectionEndIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionEndIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionLength of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_getSelectionLength00
static int tolua_CEGUI_CEGUI_Editbox_getSelectionLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Editbox* self = (const CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionLength'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getSelectionLength();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMaskCodePoint of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_getMaskCodePoint00
static int tolua_CEGUI_CEGUI_Editbox_getMaskCodePoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Editbox* self = (const CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMaskCodePoint'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getMaskCodePoint();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMaskCodePoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMaxTextLength of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_getMaxTextLength00
static int tolua_CEGUI_CEGUI_Editbox_getMaxTextLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Editbox* self = (const CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMaxTextLength'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getMaxTextLength();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMaxTextLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setReadOnly of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_setReadOnly00
static int tolua_CEGUI_CEGUI_Editbox_setReadOnly00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Editbox* self = (CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setReadOnly'",NULL);
#endif
 {
  self->setReadOnly(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setReadOnly'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTextMasked of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_setTextMasked00
static int tolua_CEGUI_CEGUI_Editbox_setTextMasked00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Editbox* self = (CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTextMasked'",NULL);
#endif
 {
  self->setTextMasked(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTextMasked'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setValidationString of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_setValidationString00
static int tolua_CEGUI_CEGUI_Editbox_setValidationString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Editbox* self = (CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
  utf8string validation_string = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValidationString'",NULL);
#endif
 {
  self->setValidationString(validation_string);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setValidationString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCaratIndex of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_setCaratIndex00
static int tolua_CEGUI_CEGUI_Editbox_setCaratIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Editbox* self = (CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long carat_pos = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCaratIndex'",NULL);
#endif
 {
  self->setCaratIndex(carat_pos);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCaratIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelection of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_setSelection00
static int tolua_CEGUI_CEGUI_Editbox_setSelection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Editbox* self = (CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long start_pos = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  unsigned long end_pos = ((unsigned long)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelection'",NULL);
#endif
 {
  self->setSelection(start_pos,end_pos);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMaskCodePoint of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_setMaskCodePoint00
static int tolua_CEGUI_CEGUI_Editbox_setMaskCodePoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Editbox* self = (CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long code_point = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMaskCodePoint'",NULL);
#endif
 {
  self->setMaskCodePoint(code_point);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMaskCodePoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMaxTextLength of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_setMaxTextLength00
static int tolua_CEGUI_CEGUI_Editbox_setMaxTextLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Editbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Editbox* self = (CEGUI::Editbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long max_len = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMaxTextLength'",NULL);
#endif
 {
  self->setMaxTextLength(max_len);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMaxTextLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: getCaratIndex of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_getCaratIndex00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_getCaratIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiLineEditbox* self = (const CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCaratIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getCaratIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCaratIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionStartIndex of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_getSelectionStartIndex00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_getSelectionStartIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiLineEditbox* self = (const CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionStartIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getSelectionStartIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionStartIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionEndIndex of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_getSelectionEndIndex00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_getSelectionEndIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiLineEditbox* self = (const CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionEndIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getSelectionEndIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionEndIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionLength of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_getSelectionLength00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_getSelectionLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiLineEditbox* self = (const CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionLength'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getSelectionLength();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMaxTextLength of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_getMaxTextLength00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_getMaxTextLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiLineEditbox* self = (const CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMaxTextLength'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getMaxTextLength();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMaxTextLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getVertScrollbar of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_getVertScrollbar00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_getVertScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiLineEditbox* self = (const CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVertScrollbar'",NULL);
#endif
 {
  CEGUI::Scrollbar* tolua_ret = (CEGUI::Scrollbar*)  self->getVertScrollbar();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Scrollbar");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVertScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getHorzScrollbar of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_getHorzScrollbar00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_getHorzScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiLineEditbox* self = (const CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHorzScrollbar'",NULL);
#endif
 {
  CEGUI::Scrollbar* tolua_ret = (CEGUI::Scrollbar*)  self->getHorzScrollbar();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Scrollbar");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorzScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTextRenderArea of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_getTextRenderArea00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_getTextRenderArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiLineEditbox* self = (const CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTextRenderArea'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getTextRenderArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTextRenderArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLineNumberFromIndex of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_getLineNumberFromIndex00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_getLineNumberFromIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiLineEditbox* self = (const CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long index = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLineNumberFromIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getLineNumberFromIndex(index);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLineNumberFromIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setReadOnly of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_setReadOnly00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_setReadOnly00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiLineEditbox* self = (CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setReadOnly'",NULL);
#endif
 {
  self->setReadOnly(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setReadOnly'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCaratIndex of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_setCaratIndex00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_setCaratIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiLineEditbox* self = (CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long carat_pos = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCaratIndex'",NULL);
#endif
 {
  self->setCaratIndex(carat_pos);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCaratIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelection of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_setSelection00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_setSelection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiLineEditbox* self = (CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long start_pos = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  unsigned long end_pos = ((unsigned long)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelection'",NULL);
#endif
 {
  self->setSelection(start_pos,end_pos);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMaxTextLength of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_setMaxTextLength00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_setMaxTextLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiLineEditbox* self = (CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long max_len = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMaxTextLength'",NULL);
#endif
 {
  self->setMaxTextLength(max_len);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMaxTextLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ensureCaratIsVisible of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_ensureCaratIsVisible00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_ensureCaratIsVisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiLineEditbox* self = (CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ensureCaratIsVisible'",NULL);
#endif
 {
  self->ensureCaratIsVisible();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ensureCaratIsVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setWordWrapping of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_setWordWrapping00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_setWordWrapping00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiLineEditbox* self = (CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWordWrapping'",NULL);
#endif
 {
  self->setWordWrapping(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWordWrapping'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setShowVertScrollbar of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_setShowVertScrollbar00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_setShowVertScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiLineEditbox* self = (CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShowVertScrollbar'",NULL);
#endif
 {
  self->setShowVertScrollbar(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShowVertScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectionBrushImage of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_setSelectionBrushImage00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_setSelectionBrushImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiLineEditbox* self = (CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Image* image = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectionBrushImage'",NULL);
#endif
 {
  self->setSelectionBrushImage(image);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelectionBrushImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionBrushImage of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_getSelectionBrushImage00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_getSelectionBrushImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiLineEditbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiLineEditbox* self = (const CEGUI::MultiLineEditbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionBrushImage'",NULL);
#endif
 {
  const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getSelectionBrushImage();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionBrushImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getText of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_getText00
static int tolua_CEGUI_CEGUI_ListboxItem_getText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListboxItem* self = (const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getText'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getText();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getID of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_getID00
static int tolua_CEGUI_CEGUI_ListboxItem_getID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListboxItem* self = (const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getID'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getID();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUserData of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_getUserData00
static int tolua_CEGUI_CEGUI_ListboxItem_getUserData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListboxItem* self = (const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUserData'",NULL);
#endif
 {
  void* tolua_ret = (void*)  self->getUserData();
 tolua_pushuserdata(tolua_S,(void*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUserData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: getOwnerWindow of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_getOwnerWindow00
static int tolua_CEGUI_CEGUI_ListboxItem_getOwnerWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOwnerWindow'",NULL);
#endif
 {
  const CEGUI::Window* tolua_ret = (const CEGUI::Window*)  self->getOwnerWindow();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOwnerWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionColours of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_getSelectionColours00
static int tolua_CEGUI_CEGUI_ListboxItem_getSelectionColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListboxItem* self = (const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionColours'",NULL);
#endif
 {
  CEGUI::ColourRect tolua_ret = (CEGUI::ColourRect)  self->getSelectionColours();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::ColourRect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ColourRect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::ColourRect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ColourRect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionBrushImage of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_getSelectionBrushImage00
static int tolua_CEGUI_CEGUI_ListboxItem_getSelectionBrushImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListboxItem* self = (const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionBrushImage'",NULL);
#endif
 {
  const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getSelectionBrushImage();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionBrushImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setText of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_setText00
static int tolua_CEGUI_CEGUI_ListboxItem_setText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setText'",NULL);
#endif
 {
  self->setText(text);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setID of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_setID00
static int tolua_CEGUI_CEGUI_ListboxItem_setID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
  unsigned int item_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setID'",NULL);
#endif
 {
  self->setID(item_id);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUserData of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_setUserData00
static int tolua_CEGUI_CEGUI_ListboxItem_setUserData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isuserdata(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
  void* item_data = ((void*)  tolua_touserdata(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUserData'",NULL);
#endif
 {
  self->setUserData(item_data);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUserData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelected of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_setSelected00
static int tolua_CEGUI_CEGUI_ListboxItem_setSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelected'",NULL);
#endif
 {
  self->setSelected(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDisabled of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_setDisabled00
static int tolua_CEGUI_CEGUI_ListboxItem_setDisabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDisabled'",NULL);
#endif
 {
  self->setDisabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDisabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAutoDeleted of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_setAutoDeleted00
static int tolua_CEGUI_CEGUI_ListboxItem_setAutoDeleted00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoDeleted'",NULL);
#endif
 {
  self->setAutoDeleted(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoDeleted'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setOwnerWindow of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_setOwnerWindow00
static int tolua_CEGUI_CEGUI_ListboxItem_setOwnerWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* owner = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOwnerWindow'",NULL);
#endif
 {
  self->setOwnerWindow(owner);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setOwnerWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectionColours of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_setSelectionColours00
static int tolua_CEGUI_CEGUI_ListboxItem_setSelectionColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ColourRect* cols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectionColours'",NULL);
#endif
 {
  self->setSelectionColours(*cols);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelectionColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectionColours of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_setSelectionColours01
static int tolua_CEGUI_CEGUI_ListboxItem_setSelectionColours01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::colour top_left_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::colour top_right_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::colour bottom_left_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::colour bottom_right_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectionColours'",NULL);
#endif
 {
  self->setSelectionColours(top_left_colour,top_right_colour,bottom_left_colour,bottom_right_colour);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ListboxItem_setSelectionColours00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectionColours of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_setSelectionColours02
static int tolua_CEGUI_CEGUI_ListboxItem_setSelectionColours02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::colour col = *((CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectionColours'",NULL);
#endif
 {
  self->setSelectionColours(col);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ListboxItem_setSelectionColours01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectionBrushImage of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_setSelectionBrushImage00
static int tolua_CEGUI_CEGUI_ListboxItem_setSelectionBrushImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Image* image = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectionBrushImage'",NULL);
#endif
 {
  self->setSelectionBrushImage(image);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelectionBrushImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectionBrushImage of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_setSelectionBrushImage01
static int tolua_CEGUI_CEGUI_ListboxItem_setSelectionBrushImage01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
  utf8string imageset = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string image = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectionBrushImage'",NULL);
#endif
 {
  self->setSelectionBrushImage(imageset,image);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ListboxItem_setSelectionBrushImage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPixelSize of class  CEGUI::ListboxItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxItem_getPixelSize00
static int tolua_CEGUI_CEGUI_ListboxItem_getPixelSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListboxItem* self = (const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPixelSize'",NULL);
#endif
 {
  CEGUI::Size tolua_ret = (CEGUI::Size)  self->getPixelSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPixelSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFont of class  CEGUI::ListboxTextItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxTextItem_getFont00
static int tolua_CEGUI_CEGUI_ListboxTextItem_getFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListboxTextItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListboxTextItem* self = (const CEGUI::ListboxTextItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFont'",NULL);
#endif
 {
  CEGUI::Font* tolua_ret = (CEGUI::Font*)  self->getFont();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Font");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFont'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTextColours of class  CEGUI::ListboxTextItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxTextItem_getTextColours00
static int tolua_CEGUI_CEGUI_ListboxTextItem_getTextColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListboxTextItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListboxTextItem* self = (const CEGUI::ListboxTextItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTextColours'",NULL);
#endif
 {
  CEGUI::ColourRect tolua_ret = (CEGUI::ColourRect)  self->getTextColours();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::ColourRect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ColourRect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::ColourRect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ColourRect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTextColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFont of class  CEGUI::ListboxTextItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxTextItem_setFont00
static int tolua_CEGUI_CEGUI_ListboxTextItem_setFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxTextItem",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListboxTextItem* self = (CEGUI::ListboxTextItem*)  tolua_tousertype(tolua_S,1,0);
  utf8string font_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFont'",NULL);
#endif
 {
  self->setFont(font_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFont'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFont of class  CEGUI::ListboxTextItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxTextItem_setFont01
static int tolua_CEGUI_CEGUI_ListboxTextItem_setFont01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxTextItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Font",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ListboxTextItem* self = (CEGUI::ListboxTextItem*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Font* font = ((CEGUI::Font*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFont'",NULL);
#endif
 {
  self->setFont(font);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ListboxTextItem_setFont00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTextColours of class  CEGUI::ListboxTextItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxTextItem_setTextColours00
static int tolua_CEGUI_CEGUI_ListboxTextItem_setTextColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxTextItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListboxTextItem* self = (CEGUI::ListboxTextItem*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::colour top_left_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::colour top_right_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::colour bottom_left_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,4,0));
  CEGUI::colour bottom_right_colour = *((CEGUI::colour*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTextColours'",NULL);
#endif
 {
  self->setTextColours(top_left_colour,top_right_colour,bottom_left_colour,bottom_right_colour);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTextColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTextColours of class  CEGUI::ListboxTextItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxTextItem_setTextColours01
static int tolua_CEGUI_CEGUI_ListboxTextItem_setTextColours01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxTextItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ListboxTextItem* self = (CEGUI::ListboxTextItem*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ColourRect* cols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTextColours'",NULL);
#endif
 {
  self->setTextColours(*cols);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ListboxTextItem_setTextColours00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTextColours of class  CEGUI::ListboxTextItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxTextItem_setTextColours02
static int tolua_CEGUI_CEGUI_ListboxTextItem_setTextColours02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxTextItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::colour",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ListboxTextItem* self = (CEGUI::ListboxTextItem*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::colour col = *((CEGUI::colour*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTextColours'",NULL);
#endif
 {
  self->setTextColours(col);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ListboxTextItem_setTextColours01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTextParsingEnabled of class  CEGUI::ListboxTextItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListboxTextItem_setTextParsingEnabled00
static int tolua_CEGUI_CEGUI_ListboxTextItem_setTextParsingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListboxTextItem",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListboxTextItem* self = (CEGUI::ListboxTextItem*)  tolua_tousertype(tolua_S,1,0);
  const bool enable = ((const bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTextParsingEnabled'",NULL);
#endif
 {
  self->setTextParsingEnabled(enable);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTextParsingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: getEditbox of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getEditbox00
static int tolua_CEGUI_CEGUI_Combobox_getEditbox00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEditbox'",NULL);
#endif
 {
  CEGUI::Editbox* tolua_ret = (CEGUI::Editbox*)  self->getEditbox();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Editbox");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEditbox'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPushButton of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getPushButton00
static int tolua_CEGUI_CEGUI_Combobox_getPushButton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPushButton'",NULL);
#endif
 {
  CEGUI::PushButton* tolua_ret = (CEGUI::PushButton*)  self->getPushButton();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::PushButton");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPushButton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDropList of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getDropList00
static int tolua_CEGUI_CEGUI_Combobox_getDropList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDropList'",NULL);
#endif
 {
  CEGUI::ComboDropList* tolua_ret = (CEGUI::ComboDropList*)  self->getDropList();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ComboDropList");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDropList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: getValidationString of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getValidationString00
static int tolua_CEGUI_CEGUI_Combobox_getValidationString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValidationString'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getValidationString();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getValidationString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCaratIndex of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getCaratIndex00
static int tolua_CEGUI_CEGUI_Combobox_getCaratIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCaratIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getCaratIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCaratIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionStartIndex of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getSelectionStartIndex00
static int tolua_CEGUI_CEGUI_Combobox_getSelectionStartIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionStartIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getSelectionStartIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionStartIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionEndIndex of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getSelectionEndIndex00
static int tolua_CEGUI_CEGUI_Combobox_getSelectionEndIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionEndIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getSelectionEndIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionEndIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionLength of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getSelectionLength00
static int tolua_CEGUI_CEGUI_Combobox_getSelectionLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionLength'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getSelectionLength();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMaxTextLength of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getMaxTextLength00
static int tolua_CEGUI_CEGUI_Combobox_getMaxTextLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMaxTextLength'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getMaxTextLength();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMaxTextLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: activateEditbox of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_activateEditbox00
static int tolua_CEGUI_CEGUI_Combobox_activateEditbox00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'activateEditbox'",NULL);
#endif
 {
  self->activateEditbox();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'activateEditbox'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemCount of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getItemCount00
static int tolua_CEGUI_CEGUI_Combobox_getItemCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemCount'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getItemCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectedItem of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getSelectedItem00
static int tolua_CEGUI_CEGUI_Combobox_getSelectedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectedItem'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->getSelectedItem();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getListboxItemFromIndex of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getListboxItemFromIndex00
static int tolua_CEGUI_CEGUI_Combobox_getListboxItemFromIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long index = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getListboxItemFromIndex'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->getListboxItemFromIndex(index);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getListboxItemFromIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemIndex of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getItemIndex00
static int tolua_CEGUI_CEGUI_Combobox_getItemIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getItemIndex(item);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isItemSelected of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_isItemSelected00
static int tolua_CEGUI_CEGUI_Combobox_isItemSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long index = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isItemSelected'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isItemSelected(index);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isItemSelected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findItemWithText of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_findItemWithText00
static int tolua_CEGUI_CEGUI_Combobox_findItemWithText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  const CEGUI::ListboxItem* start_item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findItemWithText'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->findItemWithText(text,start_item);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findItemWithText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isListboxItemInList of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_isListboxItemInList00
static int tolua_CEGUI_CEGUI_Combobox_isListboxItemInList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Combobox* self = (const CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isListboxItemInList'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isListboxItemInList(item);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isListboxItemInList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resetList of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_resetList00
static int tolua_CEGUI_CEGUI_Combobox_resetList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resetList'",NULL);
#endif
 {
  self->resetList();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resetList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addItem of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_addItem00
static int tolua_CEGUI_CEGUI_Combobox_addItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListboxItem* item = ((CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addItem'",NULL);
#endif
 {
  self->addItem(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insertItem of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_insertItem00
static int tolua_CEGUI_CEGUI_Combobox_insertItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListboxItem* item = ((CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::ListboxItem* position = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insertItem'",NULL);
#endif
 {
  self->insertItem(item,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'insertItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeItem of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_removeItem00
static int tolua_CEGUI_CEGUI_Combobox_removeItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeItem'",NULL);
#endif
 {
  self->removeItem(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearAllSelections of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_clearAllSelections00
static int tolua_CEGUI_CEGUI_Combobox_clearAllSelections00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearAllSelections'",NULL);
#endif
 {
  self->clearAllSelections();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearAllSelections'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortingEnabled of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setSortingEnabled00
static int tolua_CEGUI_CEGUI_Combobox_setSortingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortingEnabled'",NULL);
#endif
 {
  self->setSortingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setShowVertScrollbar of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setShowVertScrollbar00
static int tolua_CEGUI_CEGUI_Combobox_setShowVertScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShowVertScrollbar'",NULL);
#endif
 {
  self->setShowVertScrollbar(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShowVertScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setShowHorzScrollbar of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setShowHorzScrollbar00
static int tolua_CEGUI_CEGUI_Combobox_setShowHorzScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShowHorzScrollbar'",NULL);
#endif
 {
  self->setShowHorzScrollbar(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShowHorzScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setItemSelectState of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setItemSelectState00
static int tolua_CEGUI_CEGUI_Combobox_setItemSelectState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListboxItem* item = ((CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
  bool state = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setItemSelectState'",NULL);
#endif
 {
  self->setItemSelectState(item,state);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setItemSelectState'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setItemSelectState of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setItemSelectState01
static int tolua_CEGUI_CEGUI_Combobox_setItemSelectState01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long item_index = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  bool state = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setItemSelectState'",NULL);
#endif
 {
  self->setItemSelectState(item_index,state);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Combobox_setItemSelectState00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: handleUpdatedListItemData of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_handleUpdatedListItemData00
static int tolua_CEGUI_CEGUI_Combobox_handleUpdatedListItemData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'handleUpdatedListItemData'",NULL);
#endif
 {
  self->handleUpdatedListItemData();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'handleUpdatedListItemData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: showDropList of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_showDropList00
static int tolua_CEGUI_CEGUI_Combobox_showDropList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'showDropList'",NULL);
#endif
 {
  self->showDropList();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'showDropList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hideDropList of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_hideDropList00
static int tolua_CEGUI_CEGUI_Combobox_hideDropList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hideDropList'",NULL);
#endif
 {
  self->hideDropList();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hideDropList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSingleClickEnabled of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setSingleClickEnabled00
static int tolua_CEGUI_CEGUI_Combobox_setSingleClickEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSingleClickEnabled'",NULL);
#endif
 {
  self->setSingleClickEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSingleClickEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setReadOnly of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setReadOnly00
static int tolua_CEGUI_CEGUI_Combobox_setReadOnly00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setReadOnly'",NULL);
#endif
 {
  self->setReadOnly(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setReadOnly'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setValidationString of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setValidationString00
static int tolua_CEGUI_CEGUI_Combobox_setValidationString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  utf8string validation_string = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValidationString'",NULL);
#endif
 {
  self->setValidationString(validation_string);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setValidationString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCaratIndex of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setCaratIndex00
static int tolua_CEGUI_CEGUI_Combobox_setCaratIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long carat_pos = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCaratIndex'",NULL);
#endif
 {
  self->setCaratIndex(carat_pos);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCaratIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelection of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setSelection00
static int tolua_CEGUI_CEGUI_Combobox_setSelection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long start_pos = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  unsigned long end_pos = ((unsigned long)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelection'",NULL);
#endif
 {
  self->setSelection(start_pos,end_pos);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMaxTextLength of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setMaxTextLength00
static int tolua_CEGUI_CEGUI_Combobox_setMaxTextLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Combobox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Combobox* self = (CEGUI::Combobox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long max_len = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMaxTextLength'",NULL);
#endif
 {
  self->setMaxTextLength(max_len);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMaxTextLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemCount of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_getItemCount00
static int tolua_CEGUI_CEGUI_Listbox_getItemCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemCount'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getItemCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectedCount of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_getSelectedCount00
static int tolua_CEGUI_CEGUI_Listbox_getSelectedCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectedCount'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getSelectedCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectedCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFirstSelectedItem of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_getFirstSelectedItem00
static int tolua_CEGUI_CEGUI_Listbox_getFirstSelectedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFirstSelectedItem'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->getFirstSelectedItem();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFirstSelectedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNextSelected of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_getNextSelected00
static int tolua_CEGUI_CEGUI_Listbox_getNextSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* start_item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNextSelected'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->getNextSelected(start_item);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNextSelected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getListboxItemFromIndex of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_getListboxItemFromIndex00
static int tolua_CEGUI_CEGUI_Listbox_getListboxItemFromIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long index = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getListboxItemFromIndex'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->getListboxItemFromIndex(index);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getListboxItemFromIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemIndex of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_getItemIndex00
static int tolua_CEGUI_CEGUI_Listbox_getItemIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getItemIndex(item);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findItemWithText of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_findItemWithText00
static int tolua_CEGUI_CEGUI_Listbox_findItemWithText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  const CEGUI::ListboxItem* start_item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findItemWithText'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->findItemWithText(text,start_item);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findItemWithText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: isItemSelected of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_isItemSelected00
static int tolua_CEGUI_CEGUI_Listbox_isItemSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long index = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isItemSelected'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isItemSelected(index);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isItemSelected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isListboxItemInList of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_isListboxItemInList00
static int tolua_CEGUI_CEGUI_Listbox_isListboxItemInList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isListboxItemInList'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isListboxItemInList(item);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isListboxItemInList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: resetList of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_resetList00
static int tolua_CEGUI_CEGUI_Listbox_resetList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resetList'",NULL);
#endif
 {
  self->resetList();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resetList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addItem of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_addItem00
static int tolua_CEGUI_CEGUI_Listbox_addItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListboxItem* item = ((CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addItem'",NULL);
#endif
 {
  self->addItem(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insertItem of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_insertItem00
static int tolua_CEGUI_CEGUI_Listbox_insertItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListboxItem* item = ((CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::ListboxItem* position = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insertItem'",NULL);
#endif
 {
  self->insertItem(item,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'insertItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeItem of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_removeItem00
static int tolua_CEGUI_CEGUI_Listbox_removeItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeItem'",NULL);
#endif
 {
  self->removeItem(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearAllSelections of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_clearAllSelections00
static int tolua_CEGUI_CEGUI_Listbox_clearAllSelections00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearAllSelections'",NULL);
#endif
 {
  self->clearAllSelections();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearAllSelections'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortingEnabled of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_setSortingEnabled00
static int tolua_CEGUI_CEGUI_Listbox_setSortingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortingEnabled'",NULL);
#endif
 {
  self->setSortingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMultiselectEnabled of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_setMultiselectEnabled00
static int tolua_CEGUI_CEGUI_Listbox_setMultiselectEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMultiselectEnabled'",NULL);
#endif
 {
  self->setMultiselectEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMultiselectEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setShowVertScrollbar of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_setShowVertScrollbar00
static int tolua_CEGUI_CEGUI_Listbox_setShowVertScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShowVertScrollbar'",NULL);
#endif
 {
  self->setShowVertScrollbar(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShowVertScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setShowHorzScrollbar of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_setShowHorzScrollbar00
static int tolua_CEGUI_CEGUI_Listbox_setShowHorzScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShowHorzScrollbar'",NULL);
#endif
 {
  self->setShowHorzScrollbar(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShowHorzScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setItemSelectState of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_setItemSelectState00
static int tolua_CEGUI_CEGUI_Listbox_setItemSelectState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListboxItem* item = ((CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
  bool state = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setItemSelectState'",NULL);
#endif
 {
  self->setItemSelectState(item,state);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setItemSelectState'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setItemSelectState of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_setItemSelectState01
static int tolua_CEGUI_CEGUI_Listbox_setItemSelectState01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long item_index = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  bool state = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setItemSelectState'",NULL);
#endif
 {
  self->setItemSelectState(item_index,state);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Listbox_setItemSelectState00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: handleUpdatedItemData of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_handleUpdatedItemData00
static int tolua_CEGUI_CEGUI_Listbox_handleUpdatedItemData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'handleUpdatedItemData'",NULL);
#endif
 {
  self->handleUpdatedItemData();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'handleUpdatedItemData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ensureItemIsVisible of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_ensureItemIsVisible00
static int tolua_CEGUI_CEGUI_Listbox_ensureItemIsVisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long item_index = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ensureItemIsVisible'",NULL);
#endif
 {
  self->ensureItemIsVisible(item_index);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ensureItemIsVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ensureItemIsVisible of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_ensureItemIsVisible01
static int tolua_CEGUI_CEGUI_Listbox_ensureItemIsVisible01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Listbox* self = (CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ensureItemIsVisible'",NULL);
#endif
 {
  self->ensureItemIsVisible(item);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Listbox_ensureItemIsVisible00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getListRenderArea of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_getListRenderArea00
static int tolua_CEGUI_CEGUI_Listbox_getListRenderArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getListRenderArea'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getListRenderArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getListRenderArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVertScrollbar of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_getVertScrollbar00
static int tolua_CEGUI_CEGUI_Listbox_getVertScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVertScrollbar'",NULL);
#endif
 {
  CEGUI::Scrollbar* tolua_ret = (CEGUI::Scrollbar*)  self->getVertScrollbar();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Scrollbar");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVertScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHorzScrollbar of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_getHorzScrollbar00
static int tolua_CEGUI_CEGUI_Listbox_getHorzScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHorzScrollbar'",NULL);
#endif
 {
  CEGUI::Scrollbar* tolua_ret = (CEGUI::Scrollbar*)  self->getHorzScrollbar();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Scrollbar");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorzScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWidestItemWidth of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_getWidestItemWidth00
static int tolua_CEGUI_CEGUI_Listbox_getWidestItemWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWidestItemWidth'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getWidestItemWidth();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWidestItemWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTotalItemsHeight of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_getTotalItemsHeight00
static int tolua_CEGUI_CEGUI_Listbox_getTotalItemsHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTotalItemsHeight'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getTotalItemsHeight();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTotalItemsHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemAtPoint of class  CEGUI::Listbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Listbox_getItemAtPoint00
static int tolua_CEGUI_CEGUI_Listbox_getItemAtPoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Listbox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Listbox* self = (const CEGUI::Listbox*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2* pt = ((const CEGUI::Vector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemAtPoint'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->getItemAtPoint(*pt);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemAtPoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setArmed of class  CEGUI::ComboDropList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ComboDropList_setArmed00
static int tolua_CEGUI_CEGUI_ComboDropList_setArmed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ComboDropList",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ComboDropList* self = (CEGUI::ComboDropList*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setArmed'",NULL);
#endif
 {
  self->setArmed(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setArmed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setAutoArmEnabled of class  CEGUI::ComboDropList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ComboDropList_setAutoArmEnabled00
static int tolua_CEGUI_CEGUI_ComboDropList_setAutoArmEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ComboDropList",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ComboDropList* self = (CEGUI::ComboDropList*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoArmEnabled'",NULL);
#endif
 {
  self->setAutoArmEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoArmEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: getSortDirection of class  CEGUI::ListHeaderSegment */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeaderSegment_getSortDirection00
static int tolua_CEGUI_CEGUI_ListHeaderSegment_getSortDirection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeaderSegment* self = (const CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSortDirection'",NULL);
#endif
 {
  CEGUI::ListHeaderSegment::SortDirection tolua_ret = (CEGUI::ListHeaderSegment::SortDirection)  self->getSortDirection();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSortDirection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getDragMoveOffset of class  CEGUI::ListHeaderSegment */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeaderSegment_getDragMoveOffset00
static int tolua_CEGUI_CEGUI_ListHeaderSegment_getDragMoveOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeaderSegment* self = (const CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDragMoveOffset'",NULL);
#endif
 {
  const CEGUI::Vector2& tolua_ret = (const CEGUI::Vector2&)  self->getDragMoveOffset();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector2");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDragMoveOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setSizingEnabled of class  CEGUI::ListHeaderSegment */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeaderSegment_setSizingEnabled00
static int tolua_CEGUI_CEGUI_ListHeaderSegment_setSizingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeaderSegment* self = (CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSizingEnabled'",NULL);
#endif
 {
  self->setSizingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSizingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortDirection of class  CEGUI::ListHeaderSegment */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeaderSegment_setSortDirection00
static int tolua_CEGUI_CEGUI_ListHeaderSegment_setSortDirection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeaderSegment* self = (CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListHeaderSegment::SortDirection sort_dir = ((CEGUI::ListHeaderSegment::SortDirection) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortDirection'",NULL);
#endif
 {
  self->setSortDirection(sort_dir);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortDirection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDragMovingEnabled of class  CEGUI::ListHeaderSegment */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeaderSegment_setDragMovingEnabled00
static int tolua_CEGUI_CEGUI_ListHeaderSegment_setDragMovingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeaderSegment* self = (CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDragMovingEnabled'",NULL);
#endif
 {
  self->setDragMovingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDragMovingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setClickable of class  CEGUI::ListHeaderSegment */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeaderSegment_setClickable00
static int tolua_CEGUI_CEGUI_ListHeaderSegment_setClickable00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeaderSegment* self = (CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setClickable'",NULL);
#endif
 {
  self->setClickable(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setClickable'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColumnCount of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getColumnCount00
static int tolua_CEGUI_CEGUI_ListHeader_getColumnCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColumnCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getColumnCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColumnCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSegmentFromColumn of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getSegmentFromColumn00
static int tolua_CEGUI_CEGUI_ListHeader_getSegmentFromColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  unsigned int column = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSegmentFromColumn'",NULL);
#endif
 {
  CEGUI::ListHeaderSegment& tolua_ret = (CEGUI::ListHeaderSegment&)  self->getSegmentFromColumn(column);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::ListHeaderSegment");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSegmentFromColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSegmentFromID of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getSegmentFromID00
static int tolua_CEGUI_CEGUI_ListHeader_getSegmentFromID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  unsigned int id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSegmentFromID'",NULL);
#endif
 {
  CEGUI::ListHeaderSegment& tolua_ret = (CEGUI::ListHeaderSegment&)  self->getSegmentFromID(id);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::ListHeaderSegment");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSegmentFromID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSortSegment of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getSortSegment00
static int tolua_CEGUI_CEGUI_ListHeader_getSortSegment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSortSegment'",NULL);
#endif
 {
  CEGUI::ListHeaderSegment& tolua_ret = (CEGUI::ListHeaderSegment&)  self->getSortSegment();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::ListHeaderSegment");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSortSegment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColumnFromSegment of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getColumnFromSegment00
static int tolua_CEGUI_CEGUI_ListHeader_getColumnFromSegment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListHeaderSegment* segment = ((const CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColumnFromSegment'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getColumnFromSegment(*segment);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColumnFromSegment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColumnFromID of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getColumnFromID00
static int tolua_CEGUI_CEGUI_ListHeader_getColumnFromID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  unsigned int id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColumnFromID'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getColumnFromID(id);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColumnFromID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSortColumn of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getSortColumn00
static int tolua_CEGUI_CEGUI_ListHeader_getSortColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSortColumn'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getSortColumn();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSortColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColumnWithText of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getColumnWithText00
static int tolua_CEGUI_CEGUI_ListHeader_getColumnWithText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColumnWithText'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getColumnWithText(text);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColumnWithText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPixelOffsetToSegment of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getPixelOffsetToSegment00
static int tolua_CEGUI_CEGUI_ListHeader_getPixelOffsetToSegment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListHeaderSegment* segment = ((const CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPixelOffsetToSegment'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getPixelOffsetToSegment(*segment);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPixelOffsetToSegment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPixelOffsetToColumn of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getPixelOffsetToColumn00
static int tolua_CEGUI_CEGUI_ListHeader_getPixelOffsetToColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  unsigned int column = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPixelOffsetToColumn'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getPixelOffsetToColumn(column);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPixelOffsetToColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTotalSegmentsPixelExtent of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getTotalSegmentsPixelExtent00
static int tolua_CEGUI_CEGUI_ListHeader_getTotalSegmentsPixelExtent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTotalSegmentsPixelExtent'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getTotalSegmentsPixelExtent();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTotalSegmentsPixelExtent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColumnWidth of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getColumnWidth00
static int tolua_CEGUI_CEGUI_ListHeader_getColumnWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  unsigned int column = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColumnWidth'",NULL);
#endif
 {
  CEGUI::UDim tolua_ret = (CEGUI::UDim)  self->getColumnWidth(column);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UDim(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UDim));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColumnWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSortDirection of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getSortDirection00
static int tolua_CEGUI_CEGUI_ListHeader_getSortDirection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSortDirection'",NULL);
#endif
 {
  CEGUI::ListHeaderSegment::SortDirection tolua_ret = (CEGUI::ListHeaderSegment::SortDirection)  self->getSortDirection();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSortDirection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: getSegmentOffset of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_getSegmentOffset00
static int tolua_CEGUI_CEGUI_ListHeader_getSegmentOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ListHeader* self = (const CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSegmentOffset'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getSegmentOffset();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSegmentOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortingEnabled of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_setSortingEnabled00
static int tolua_CEGUI_CEGUI_ListHeader_setSortingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortingEnabled'",NULL);
#endif
 {
  self->setSortingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortDirection of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_setSortDirection00
static int tolua_CEGUI_CEGUI_ListHeader_setSortDirection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListHeaderSegment::SortDirection direction = ((CEGUI::ListHeaderSegment::SortDirection) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortDirection'",NULL);
#endif
 {
  self->setSortDirection(direction);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortDirection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortSegment of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_setSortSegment00
static int tolua_CEGUI_CEGUI_ListHeader_setSortSegment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListHeaderSegment* segment = ((const CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortSegment'",NULL);
#endif
 {
  self->setSortSegment(*segment);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortSegment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortColumn of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_setSortColumn00
static int tolua_CEGUI_CEGUI_ListHeader_setSortColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  unsigned int column = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortColumn'",NULL);
#endif
 {
  self->setSortColumn(column);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortColumnFromID of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_setSortColumnFromID00
static int tolua_CEGUI_CEGUI_ListHeader_setSortColumnFromID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  unsigned int id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortColumnFromID'",NULL);
#endif
 {
  self->setSortColumnFromID(id);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortColumnFromID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setColumnSizingEnabled of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_setColumnSizingEnabled00
static int tolua_CEGUI_CEGUI_ListHeader_setColumnSizingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setColumnSizingEnabled'",NULL);
#endif
 {
  self->setColumnSizingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setColumnSizingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setColumnDraggingEnabled of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_setColumnDraggingEnabled00
static int tolua_CEGUI_CEGUI_ListHeader_setColumnDraggingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setColumnDraggingEnabled'",NULL);
#endif
 {
  self->setColumnDraggingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setColumnDraggingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addColumn of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_addColumn00
static int tolua_CEGUI_CEGUI_ListHeader_addColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  unsigned int id = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  const CEGUI::UDim* width = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addColumn'",NULL);
#endif
 {
  self->addColumn(text,id,*width);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insertColumn of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_insertColumn00
static int tolua_CEGUI_CEGUI_ListHeader_insertColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  unsigned int id = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  const CEGUI::UDim* width = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,4,0));
  unsigned int position = ((unsigned int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insertColumn'",NULL);
#endif
 {
  self->insertColumn(text,id,*width,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'insertColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insertColumn of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_insertColumn01
static int tolua_CEGUI_CEGUI_ListHeader_insertColumn01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  unsigned int id = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  const CEGUI::UDim* width = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::ListHeaderSegment* position = ((const CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insertColumn'",NULL);
#endif
 {
  self->insertColumn(text,id,*width,*position);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ListHeader_insertColumn00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeColumn of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_removeColumn00
static int tolua_CEGUI_CEGUI_ListHeader_removeColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  unsigned int column = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeColumn'",NULL);
#endif
 {
  self->removeColumn(column);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeSegment of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_removeSegment00
static int tolua_CEGUI_CEGUI_ListHeader_removeSegment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListHeaderSegment* segment = ((const CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeSegment'",NULL);
#endif
 {
  self->removeSegment(*segment);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeSegment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveColumn of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_moveColumn00
static int tolua_CEGUI_CEGUI_ListHeader_moveColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  unsigned int column = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int position = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveColumn'",NULL);
#endif
 {
  self->moveColumn(column,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveColumn of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_moveColumn01
static int tolua_CEGUI_CEGUI_ListHeader_moveColumn01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  unsigned int column = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  const CEGUI::ListHeaderSegment* position = ((const CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveColumn'",NULL);
#endif
 {
  self->moveColumn(column,*position);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ListHeader_moveColumn00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveSegment of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_moveSegment00
static int tolua_CEGUI_CEGUI_ListHeader_moveSegment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListHeaderSegment* segment = ((const CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,2,0));
  unsigned int position = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveSegment'",NULL);
#endif
 {
  self->moveSegment(*segment,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveSegment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveSegment of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_moveSegment01
static int tolua_CEGUI_CEGUI_ListHeader_moveSegment01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ListHeaderSegment",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListHeaderSegment* segment = ((const CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::ListHeaderSegment* position = ((const CEGUI::ListHeaderSegment*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveSegment'",NULL);
#endif
 {
  self->moveSegment(*segment,*position);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ListHeader_moveSegment00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSegmentOffset of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_setSegmentOffset00
static int tolua_CEGUI_CEGUI_ListHeader_setSegmentOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  float offset = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSegmentOffset'",NULL);
#endif
 {
  self->setSegmentOffset(offset);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSegmentOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setColumnWidth of class  CEGUI::ListHeader */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ListHeader_setColumnWidth00
static int tolua_CEGUI_CEGUI_ListHeader_setColumnWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ListHeader",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ListHeader* self = (CEGUI::ListHeader*)  tolua_tousertype(tolua_S,1,0);
  unsigned int column = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  const CEGUI::UDim* width = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setColumnWidth'",NULL);
#endif
 {
  self->setColumnWidth(column,*width);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setColumnWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: row of class  CEGUI::MCLGridRef */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__MCLGridRef_unsigned_row
static int tolua_get_CEGUI__MCLGridRef_unsigned_row(lua_State* tolua_S)
{
  CEGUI::MCLGridRef* self = (CEGUI::MCLGridRef*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'row'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->row);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: row of class  CEGUI::MCLGridRef */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__MCLGridRef_unsigned_row
static int tolua_set_CEGUI__MCLGridRef_unsigned_row(lua_State* tolua_S)
{
  CEGUI::MCLGridRef* self = (CEGUI::MCLGridRef*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'row'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->row = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: column of class  CEGUI::MCLGridRef */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__MCLGridRef_unsigned_column
static int tolua_get_CEGUI__MCLGridRef_unsigned_column(lua_State* tolua_S)
{
  CEGUI::MCLGridRef* self = (CEGUI::MCLGridRef*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'column'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->column);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: column of class  CEGUI::MCLGridRef */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__MCLGridRef_unsigned_column
static int tolua_set_CEGUI__MCLGridRef_unsigned_column(lua_State* tolua_S)
{
  CEGUI::MCLGridRef* self = (CEGUI::MCLGridRef*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'column'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->column = ((unsigned int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::MCLGridRef */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MCLGridRef__eq00
static int tolua_CEGUI_CEGUI_MCLGridRef__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MCLGridRef",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::MCLGridRef",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MCLGridRef* self = (const CEGUI::MCLGridRef*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::MCLGridRef* rhs = ((const CEGUI::MCLGridRef*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator==(*rhs);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::MCLGridRef */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MCLGridRef_new00
static int tolua_CEGUI_CEGUI_MCLGridRef_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::MCLGridRef",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  unsigned int r = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int c = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::MCLGridRef* tolua_ret = (CEGUI::MCLGridRef*)  new CEGUI::MCLGridRef(r,c);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::MCLGridRef");
 }
 }
 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  CEGUI::MCLGridRef */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MCLGridRef_new00_local
static int tolua_CEGUI_CEGUI_MCLGridRef_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::MCLGridRef",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  unsigned int r = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int c = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::MCLGridRef* tolua_ret = (CEGUI::MCLGridRef*)  new CEGUI::MCLGridRef(r,c);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::MCLGridRef");
 }
 }
 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: isUserSortControlEnabled of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_isUserSortControlEnabled00
static int tolua_CEGUI_CEGUI_MultiColumnList_isUserSortControlEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isUserSortControlEnabled'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isUserSortControlEnabled();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isUserSortControlEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: getColumnCount of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getColumnCount00
static int tolua_CEGUI_CEGUI_MultiColumnList_getColumnCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColumnCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getColumnCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColumnCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRowCount of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getRowCount00
static int tolua_CEGUI_CEGUI_MultiColumnList_getRowCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRowCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getRowCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRowCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSortColumn of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getSortColumn00
static int tolua_CEGUI_CEGUI_MultiColumnList_getSortColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSortColumn'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getSortColumn();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSortColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColumnWithID of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getColumnWithID00
static int tolua_CEGUI_CEGUI_MultiColumnList_getColumnWithID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColumnWithID'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getColumnWithID(col_id);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColumnWithID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColumnWithHeaderText of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getColumnWithHeaderText00
static int tolua_CEGUI_CEGUI_MultiColumnList_getColumnWithHeaderText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColumnWithHeaderText'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getColumnWithHeaderText(text);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColumnWithHeaderText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTotalColumnHeadersWidth of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getTotalColumnHeadersWidth00
static int tolua_CEGUI_CEGUI_MultiColumnList_getTotalColumnHeadersWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTotalColumnHeadersWidth'",NULL);
#endif
 {
  CEGUI::UDim tolua_ret = (CEGUI::UDim)  self->getTotalColumnHeadersWidth();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UDim(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UDim));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTotalColumnHeadersWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColumnHeaderWidth of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getColumnHeaderWidth00
static int tolua_CEGUI_CEGUI_MultiColumnList_getColumnHeaderWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColumnHeaderWidth'",NULL);
#endif
 {
  CEGUI::UDim tolua_ret = (CEGUI::UDim)  self->getColumnHeaderWidth(col_idx);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::UDim(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::UDim));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::UDim");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColumnHeaderWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSortDirection of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getSortDirection00
static int tolua_CEGUI_CEGUI_MultiColumnList_getSortDirection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSortDirection'",NULL);
#endif
 {
  CEGUI::ListHeaderSegment::SortDirection tolua_ret = (CEGUI::ListHeaderSegment::SortDirection)  self->getSortDirection();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSortDirection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHeaderSegmentForColumn of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getHeaderSegmentForColumn00
static int tolua_CEGUI_CEGUI_MultiColumnList_getHeaderSegmentForColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHeaderSegmentForColumn'",NULL);
#endif
 {
  CEGUI::ListHeaderSegment& tolua_ret = (CEGUI::ListHeaderSegment&)  self->getHeaderSegmentForColumn(col_idx);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::ListHeaderSegment");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHeaderSegmentForColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemRowIndex of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getItemRowIndex00
static int tolua_CEGUI_CEGUI_MultiColumnList_getItemRowIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemRowIndex'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getItemRowIndex(item);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemRowIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemColumnIndex of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getItemColumnIndex00
static int tolua_CEGUI_CEGUI_MultiColumnList_getItemColumnIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemColumnIndex'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getItemColumnIndex(item);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemColumnIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemGridReference of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getItemGridReference00
static int tolua_CEGUI_CEGUI_MultiColumnList_getItemGridReference00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemGridReference'",NULL);
#endif
 {
  CEGUI::MCLGridRef tolua_ret = (CEGUI::MCLGridRef)  self->getItemGridReference(item);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::MCLGridRef(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::MCLGridRef");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::MCLGridRef));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::MCLGridRef");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemGridReference'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemAtGridReference of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getItemAtGridReference00
static int tolua_CEGUI_CEGUI_MultiColumnList_getItemAtGridReference00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::MCLGridRef",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::MCLGridRef* grid_ref = ((const CEGUI::MCLGridRef*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemAtGridReference'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->getItemAtGridReference(*grid_ref);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemAtGridReference'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isListboxItemInColumn of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_isListboxItemInColumn00
static int tolua_CEGUI_CEGUI_MultiColumnList_isListboxItemInColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
  unsigned int col_idx = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isListboxItemInColumn'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isListboxItemInColumn(item,col_idx);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isListboxItemInColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isListboxItemInRow of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_isListboxItemInRow00
static int tolua_CEGUI_CEGUI_MultiColumnList_isListboxItemInRow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
  unsigned int row_idx = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isListboxItemInRow'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isListboxItemInRow(item,row_idx);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isListboxItemInRow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isListboxItemInList of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_isListboxItemInList00
static int tolua_CEGUI_CEGUI_MultiColumnList_isListboxItemInList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isListboxItemInList'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isListboxItemInList(item);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isListboxItemInList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findColumnItemWithText of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_findColumnItemWithText00
static int tolua_CEGUI_CEGUI_MultiColumnList_findColumnItemWithText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  unsigned int col_idx = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  const CEGUI::ListboxItem* start_item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findColumnItemWithText'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->findColumnItemWithText(text,col_idx,start_item);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findColumnItemWithText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findRowItemWithText of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_findRowItemWithText00
static int tolua_CEGUI_CEGUI_MultiColumnList_findRowItemWithText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  unsigned int row_idx = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  const CEGUI::ListboxItem* start_item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findRowItemWithText'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->findRowItemWithText(text,row_idx,start_item);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findRowItemWithText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findListItemWithText of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_findListItemWithText00
static int tolua_CEGUI_CEGUI_MultiColumnList_findListItemWithText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  const CEGUI::ListboxItem* start_item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findListItemWithText'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->findListItemWithText(text,start_item);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findListItemWithText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFirstSelectedItem of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getFirstSelectedItem00
static int tolua_CEGUI_CEGUI_MultiColumnList_getFirstSelectedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFirstSelectedItem'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->getFirstSelectedItem();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFirstSelectedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNextSelected of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getNextSelected00
static int tolua_CEGUI_CEGUI_MultiColumnList_getNextSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ListboxItem* start_item = ((const CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNextSelected'",NULL);
#endif
 {
  CEGUI::ListboxItem* tolua_ret = (CEGUI::ListboxItem*)  self->getNextSelected(start_item);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNextSelected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectedCount of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getSelectedCount00
static int tolua_CEGUI_CEGUI_MultiColumnList_getSelectedCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectedCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getSelectedCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectedCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isItemSelected of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_isItemSelected00
static int tolua_CEGUI_CEGUI_MultiColumnList_isItemSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::MCLGridRef",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::MCLGridRef* grid_ref = ((const CEGUI::MCLGridRef*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isItemSelected'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isItemSelected(*grid_ref);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isItemSelected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNominatedSelectionColumnID of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getNominatedSelectionColumnID00
static int tolua_CEGUI_CEGUI_MultiColumnList_getNominatedSelectionColumnID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNominatedSelectionColumnID'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getNominatedSelectionColumnID();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNominatedSelectionColumnID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNominatedSelectionColumn of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getNominatedSelectionColumn00
static int tolua_CEGUI_CEGUI_MultiColumnList_getNominatedSelectionColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNominatedSelectionColumn'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getNominatedSelectionColumn();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNominatedSelectionColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNominatedSelectionRow of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getNominatedSelectionRow00
static int tolua_CEGUI_CEGUI_MultiColumnList_getNominatedSelectionRow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNominatedSelectionRow'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getNominatedSelectionRow();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNominatedSelectionRow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectionMode of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getSelectionMode00
static int tolua_CEGUI_CEGUI_MultiColumnList_getSelectionMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectionMode'",NULL);
#endif
 {
  CEGUI::MultiColumnList::SelectionMode tolua_ret = (CEGUI::MultiColumnList::SelectionMode)  self->getSelectionMode();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectionMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: getColumnID of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getColumnID00
static int tolua_CEGUI_CEGUI_MultiColumnList_getColumnID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColumnID'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getColumnID(col_idx);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColumnID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRowID of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getRowID00
static int tolua_CEGUI_CEGUI_MultiColumnList_getRowID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int row_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRowID'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getRowID(row_idx);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRowID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRowWithID of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getRowWithID00
static int tolua_CEGUI_CEGUI_MultiColumnList_getRowWithID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int row_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRowWithID'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getRowWithID(row_id);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRowWithID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getListRenderArea of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getListRenderArea00
static int tolua_CEGUI_CEGUI_MultiColumnList_getListRenderArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getListRenderArea'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getListRenderArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getListRenderArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVertScrollbar of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getVertScrollbar00
static int tolua_CEGUI_CEGUI_MultiColumnList_getVertScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVertScrollbar'",NULL);
#endif
 {
  CEGUI::Scrollbar* tolua_ret = (CEGUI::Scrollbar*)  self->getVertScrollbar();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Scrollbar");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVertScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHorzScrollbar of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getHorzScrollbar00
static int tolua_CEGUI_CEGUI_MultiColumnList_getHorzScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHorzScrollbar'",NULL);
#endif
 {
  CEGUI::Scrollbar* tolua_ret = (CEGUI::Scrollbar*)  self->getHorzScrollbar();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Scrollbar");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorzScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getListHeader of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getListHeader00
static int tolua_CEGUI_CEGUI_MultiColumnList_getListHeader00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getListHeader'",NULL);
#endif
 {
  CEGUI::ListHeader* tolua_ret = (CEGUI::ListHeader*)  self->getListHeader();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListHeader");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getListHeader'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTotalRowsHeight of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getTotalRowsHeight00
static int tolua_CEGUI_CEGUI_MultiColumnList_getTotalRowsHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTotalRowsHeight'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getTotalRowsHeight();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTotalRowsHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWidestColumnItemWidth of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getWidestColumnItemWidth00
static int tolua_CEGUI_CEGUI_MultiColumnList_getWidestColumnItemWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWidestColumnItemWidth'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getWidestColumnItemWidth(col_idx);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWidestColumnItemWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHighestRowItemHeight of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getHighestRowItemHeight00
static int tolua_CEGUI_CEGUI_MultiColumnList_getHighestRowItemHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MultiColumnList* self = (const CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int row_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHighestRowItemHeight'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getHighestRowItemHeight(row_idx);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHighestRowItemHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resetList of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_resetList00
static int tolua_CEGUI_CEGUI_MultiColumnList_resetList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resetList'",NULL);
#endif
 {
  self->resetList();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resetList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addColumn of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_addColumn00
static int tolua_CEGUI_CEGUI_MultiColumnList_addColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  unsigned int col_id = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  const CEGUI::UDim* width = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addColumn'",NULL);
#endif
 {
  self->addColumn(text,col_id,*width);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insertColumn of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_insertColumn00
static int tolua_CEGUI_CEGUI_MultiColumnList_insertColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  unsigned int col_id = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  const CEGUI::UDim* width = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,4,0));
  unsigned int position = ((unsigned int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insertColumn'",NULL);
#endif
 {
  self->insertColumn(text,col_id,*width,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'insertColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeColumn of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_removeColumn00
static int tolua_CEGUI_CEGUI_MultiColumnList_removeColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeColumn'",NULL);
#endif
 {
  self->removeColumn(col_idx);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeColumnWithID of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_removeColumnWithID00
static int tolua_CEGUI_CEGUI_MultiColumnList_removeColumnWithID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeColumnWithID'",NULL);
#endif
 {
  self->removeColumnWithID(col_id);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeColumnWithID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveColumn of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_moveColumn00
static int tolua_CEGUI_CEGUI_MultiColumnList_moveColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int position = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveColumn'",NULL);
#endif
 {
  self->moveColumn(col_idx,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveColumnWithID of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_moveColumnWithID00
static int tolua_CEGUI_CEGUI_MultiColumnList_moveColumnWithID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int position = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveColumnWithID'",NULL);
#endif
 {
  self->moveColumnWithID(col_id,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveColumnWithID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addRow of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_addRow00
static int tolua_CEGUI_CEGUI_MultiColumnList_addRow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addRow'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->addRow();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addRow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addRow of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_addRow01
static int tolua_CEGUI_CEGUI_MultiColumnList_addRow01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListboxItem* item = ((CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
  unsigned int col_id = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addRow'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->addRow(item,col_id);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_MultiColumnList_addRow00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: insertRow of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_insertRow00
static int tolua_CEGUI_CEGUI_MultiColumnList_insertRow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int row_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insertRow'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->insertRow(row_idx);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'insertRow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insertRow of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_insertRow01
static int tolua_CEGUI_CEGUI_MultiColumnList_insertRow01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListboxItem* item = ((CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
  unsigned int col_id = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  unsigned int row_idx = ((unsigned int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insertRow'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->insertRow(item,col_id,row_idx);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_MultiColumnList_insertRow00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeRow of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_removeRow00
static int tolua_CEGUI_CEGUI_MultiColumnList_removeRow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int row_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeRow'",NULL);
#endif
 {
  self->removeRow(row_idx);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeRow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setItem of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setItem00
static int tolua_CEGUI_CEGUI_MultiColumnList_setItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::MCLGridRef",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListboxItem* item = ((CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::MCLGridRef* position = ((const CEGUI::MCLGridRef*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setItem'",NULL);
#endif
 {
  self->setItem(item,*position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setItem of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setItem01
static int tolua_CEGUI_CEGUI_MultiColumnList_setItem01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListboxItem* item = ((CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
  unsigned int col_id = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  unsigned int row_idx = ((unsigned int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setItem'",NULL);
#endif
 {
  self->setItem(item,col_id,row_idx);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_MultiColumnList_setItem00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectionMode of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setSelectionMode00
static int tolua_CEGUI_CEGUI_MultiColumnList_setSelectionMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MultiColumnList::SelectionMode sel_mode = ((CEGUI::MultiColumnList::SelectionMode) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectionMode'",NULL);
#endif
 {
  self->setSelectionMode(sel_mode);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelectionMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNominatedSelectionColumnID of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setNominatedSelectionColumnID00
static int tolua_CEGUI_CEGUI_MultiColumnList_setNominatedSelectionColumnID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNominatedSelectionColumnID'",NULL);
#endif
 {
  self->setNominatedSelectionColumnID(col_id);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNominatedSelectionColumnID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNominatedSelectionColumn of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setNominatedSelectionColumn00
static int tolua_CEGUI_CEGUI_MultiColumnList_setNominatedSelectionColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNominatedSelectionColumn'",NULL);
#endif
 {
  self->setNominatedSelectionColumn(col_idx);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNominatedSelectionColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNominatedSelectionRow of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setNominatedSelectionRow00
static int tolua_CEGUI_CEGUI_MultiColumnList_setNominatedSelectionRow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int row_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNominatedSelectionRow'",NULL);
#endif
 {
  self->setNominatedSelectionRow(row_idx);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNominatedSelectionRow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortDirection of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setSortDirection00
static int tolua_CEGUI_CEGUI_MultiColumnList_setSortDirection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListHeaderSegment::SortDirection direction = ((CEGUI::ListHeaderSegment::SortDirection) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortDirection'",NULL);
#endif
 {
  self->setSortDirection(direction);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortDirection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortColumn of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setSortColumn00
static int tolua_CEGUI_CEGUI_MultiColumnList_setSortColumn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortColumn'",NULL);
#endif
 {
  self->setSortColumn(col_idx);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortColumn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortColumnByID of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setSortColumnByID00
static int tolua_CEGUI_CEGUI_MultiColumnList_setSortColumnByID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortColumnByID'",NULL);
#endif
 {
  self->setSortColumnByID(col_id);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortColumnByID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setShowVertScrollbar of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setShowVertScrollbar00
static int tolua_CEGUI_CEGUI_MultiColumnList_setShowVertScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShowVertScrollbar'",NULL);
#endif
 {
  self->setShowVertScrollbar(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShowVertScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setShowHorzScrollbar of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setShowHorzScrollbar00
static int tolua_CEGUI_CEGUI_MultiColumnList_setShowHorzScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShowHorzScrollbar'",NULL);
#endif
 {
  self->setShowHorzScrollbar(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShowHorzScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearAllSelections of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_clearAllSelections00
static int tolua_CEGUI_CEGUI_MultiColumnList_clearAllSelections00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearAllSelections'",NULL);
#endif
 {
  self->clearAllSelections();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearAllSelections'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setItemSelectState of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setItemSelectState00
static int tolua_CEGUI_CEGUI_MultiColumnList_setItemSelectState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ListboxItem",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ListboxItem* item = ((CEGUI::ListboxItem*)  tolua_tousertype(tolua_S,2,0));
  bool state = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setItemSelectState'",NULL);
#endif
 {
  self->setItemSelectState(item,state);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setItemSelectState'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setItemSelectState of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setItemSelectState01
static int tolua_CEGUI_CEGUI_MultiColumnList_setItemSelectState01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::MCLGridRef",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::MCLGridRef* grid_ref = ((const CEGUI::MCLGridRef*)  tolua_tousertype(tolua_S,2,0));
  bool state = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setItemSelectState'",NULL);
#endif
 {
  self->setItemSelectState(*grid_ref,state);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_MultiColumnList_setItemSelectState00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: handleUpdatedItemData of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_handleUpdatedItemData00
static int tolua_CEGUI_CEGUI_MultiColumnList_handleUpdatedItemData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'handleUpdatedItemData'",NULL);
#endif
 {
  self->handleUpdatedItemData();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'handleUpdatedItemData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setColumnHeaderWidth of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setColumnHeaderWidth00
static int tolua_CEGUI_CEGUI_MultiColumnList_setColumnHeaderWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  const CEGUI::UDim* width = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setColumnHeaderWidth'",NULL);
#endif
 {
  self->setColumnHeaderWidth(col_idx,*width);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setColumnHeaderWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUserSortControlEnabled of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setUserSortControlEnabled00
static int tolua_CEGUI_CEGUI_MultiColumnList_setUserSortControlEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUserSortControlEnabled'",NULL);
#endif
 {
  self->setUserSortControlEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUserSortControlEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUserColumnSizingEnabled of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setUserColumnSizingEnabled00
static int tolua_CEGUI_CEGUI_MultiColumnList_setUserColumnSizingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUserColumnSizingEnabled'",NULL);
#endif
 {
  self->setUserColumnSizingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUserColumnSizingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUserColumnDraggingEnabled of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setUserColumnDraggingEnabled00
static int tolua_CEGUI_CEGUI_MultiColumnList_setUserColumnDraggingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUserColumnDraggingEnabled'",NULL);
#endif
 {
  self->setUserColumnDraggingEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUserColumnDraggingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: autoSizeColumnHeader of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_autoSizeColumnHeader00
static int tolua_CEGUI_CEGUI_MultiColumnList_autoSizeColumnHeader00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int col_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'autoSizeColumnHeader'",NULL);
#endif
 {
  self->autoSizeColumnHeader(col_idx);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'autoSizeColumnHeader'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRowID of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setRowID00
static int tolua_CEGUI_CEGUI_MultiColumnList_setRowID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MultiColumnList",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MultiColumnList* self = (CEGUI::MultiColumnList*)  tolua_tousertype(tolua_S,1,0);
  unsigned int row_idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int row_id = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRowID'",NULL);
#endif
 {
  self->setRowID(row_idx,row_id);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRowID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemPixelSize of class  CEGUI::ItemEntry */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemEntry_getItemPixelSize00
static int tolua_CEGUI_CEGUI_ItemEntry_getItemPixelSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemEntry* self = (CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemPixelSize'",NULL);
#endif
 {
  CEGUI::Size tolua_ret = (CEGUI::Size)  self->getItemPixelSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemPixelSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOwnerList of class  CEGUI::ItemEntry */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemEntry_getOwnerList00
static int tolua_CEGUI_CEGUI_ItemEntry_getOwnerList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemEntry* self = (const CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOwnerList'",NULL);
#endif
 {
  CEGUI::ItemListBase* tolua_ret = (CEGUI::ItemListBase*)  self->getOwnerList();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ItemListBase");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOwnerList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: setSelected of class  CEGUI::ItemEntry */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemEntry_setSelected00
static int tolua_CEGUI_CEGUI_ItemEntry_setSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemEntry* self = (CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelected'",NULL);
#endif
 {
  self->setSelected(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: select of class  CEGUI::ItemEntry */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemEntry_select00
static int tolua_CEGUI_CEGUI_ItemEntry_select00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemEntry* self = (CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'select'",NULL);
#endif
 {
  self->select();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'select'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: deselect of class  CEGUI::ItemEntry */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemEntry_deselect00
static int tolua_CEGUI_CEGUI_ItemEntry_deselect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemEntry* self = (CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'deselect'",NULL);
#endif
 {
  self->deselect();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'deselect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSelectable of class  CEGUI::ItemEntry */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemEntry_setSelectable00
static int tolua_CEGUI_CEGUI_ItemEntry_setSelectable00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemEntry* self = (CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSelectable'",NULL);
#endif
 {
  self->setSelectable(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSelectable'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemCount of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_getItemCount00
static int tolua_CEGUI_CEGUI_ItemListBase_getItemCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemListBase* self = (const CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemCount'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getItemCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemFromIndex of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_getItemFromIndex00
static int tolua_CEGUI_CEGUI_ItemListBase_getItemFromIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemListBase* self = (const CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
  unsigned int index = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemFromIndex'",NULL);
#endif
 {
  CEGUI::ItemEntry* tolua_ret = (CEGUI::ItemEntry*)  self->getItemFromIndex(index);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ItemEntry");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemFromIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemIndex of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_getItemIndex00
static int tolua_CEGUI_CEGUI_ItemListBase_getItemIndex00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemListBase* self = (const CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ItemEntry* item = ((const CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemIndex'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getItemIndex(item);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemIndex'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findItemWithText of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_findItemWithText00
static int tolua_CEGUI_CEGUI_ItemListBase_findItemWithText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListBase* self = (CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  const CEGUI::ItemEntry* start_item = ((const CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findItemWithText'",NULL);
#endif
 {
  CEGUI::ItemEntry* tolua_ret = (CEGUI::ItemEntry*)  self->findItemWithText(text,start_item);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ItemEntry");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findItemWithText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isItemInList of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_isItemInList00
static int tolua_CEGUI_CEGUI_ItemListBase_isItemInList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemListBase* self = (const CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ItemEntry* item = ((const CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isItemInList'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isItemInList(item);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isItemInList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: getSortMode of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_getSortMode00
static int tolua_CEGUI_CEGUI_ItemListBase_getSortMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemListBase* self = (const CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSortMode'",NULL);
#endif
 {
  CEGUI::ItemListBase::SortMode tolua_ret = (CEGUI::ItemListBase::SortMode)  self->getSortMode();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSortMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemRenderArea of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_getItemRenderArea00
static int tolua_CEGUI_CEGUI_ItemListBase_getItemRenderArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemListBase* self = (const CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemRenderArea'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getItemRenderArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemRenderArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getContentPane of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_getContentPane00
static int tolua_CEGUI_CEGUI_ItemListBase_getContentPane00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemListBase* self = (const CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getContentPane'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getContentPane();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getContentPane'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resetList of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_resetList00
static int tolua_CEGUI_CEGUI_ItemListBase_resetList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListBase* self = (CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resetList'",NULL);
#endif
 {
  self->resetList();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resetList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addItem of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_addItem00
static int tolua_CEGUI_CEGUI_ItemListBase_addItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListBase* self = (CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ItemEntry* item = ((CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addItem'",NULL);
#endif
 {
  self->addItem(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insertItem of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_insertItem00
static int tolua_CEGUI_CEGUI_ItemListBase_insertItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListBase* self = (CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ItemEntry* item = ((CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::ItemEntry* position = ((const CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'insertItem'",NULL);
#endif
 {
  self->insertItem(item,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'insertItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeItem of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_removeItem00
static int tolua_CEGUI_CEGUI_ItemListBase_removeItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListBase* self = (CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ItemEntry* item = ((CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeItem'",NULL);
#endif
 {
  self->removeItem(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: handleUpdatedItemData of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_handleUpdatedItemData00
static int tolua_CEGUI_CEGUI_ItemListBase_handleUpdatedItemData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListBase* self = (CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'handleUpdatedItemData'",NULL);
#endif
 {
  self->handleUpdatedItemData();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'handleUpdatedItemData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAutoResizeEnabled of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_setAutoResizeEnabled00
static int tolua_CEGUI_CEGUI_ItemListBase_setAutoResizeEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListBase* self = (CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoResizeEnabled'",NULL);
#endif
 {
  self->setAutoResizeEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoResizeEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sizeToContent of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_sizeToContent00
static int tolua_CEGUI_CEGUI_ItemListBase_sizeToContent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListBase* self = (CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sizeToContent'",NULL);
#endif
 {
  self->sizeToContent();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sizeToContent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortEnabled of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_setSortEnabled00
static int tolua_CEGUI_CEGUI_ItemListBase_setSortEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListBase* self = (CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortEnabled'",NULL);
#endif
 {
  self->setSortEnabled(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSortMode of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_setSortMode00
static int tolua_CEGUI_CEGUI_ItemListBase_setSortMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListBase* self = (CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ItemListBase::SortMode mode = ((CEGUI::ItemListBase::SortMode) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSortMode'",NULL);
#endif
 {
  self->setSortMode(mode);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSortMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sortList of class  CEGUI::ItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListBase_sortList00
static int tolua_CEGUI_CEGUI_ItemListBase_sortList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListBase* self = (CEGUI::ItemListBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sortList'",NULL);
#endif
 {
  self->sortList();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sortList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItemSpacing of class  CEGUI::MenuBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuBase_getItemSpacing00
static int tolua_CEGUI_CEGUI_MenuBase_getItemSpacing00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MenuBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MenuBase* self = (const CEGUI::MenuBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItemSpacing'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getItemSpacing();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItemSpacing'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getPopupMenuItem of class  CEGUI::MenuBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuBase_getPopupMenuItem00
static int tolua_CEGUI_CEGUI_MenuBase_getPopupMenuItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MenuBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MenuBase* self = (const CEGUI::MenuBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPopupMenuItem'",NULL);
#endif
 {
  CEGUI::MenuItem* tolua_ret = (CEGUI::MenuItem*)  self->getPopupMenuItem();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::MenuItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPopupMenuItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setItemSpacing of class  CEGUI::MenuBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuBase_setItemSpacing00
static int tolua_CEGUI_CEGUI_MenuBase_setItemSpacing00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MenuBase",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MenuBase* self = (CEGUI::MenuBase*)  tolua_tousertype(tolua_S,1,0);
  float spacing = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setItemSpacing'",NULL);
#endif
 {
  self->setItemSpacing(spacing);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setItemSpacing'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: changePopupMenuItem of class  CEGUI::MenuBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuBase_changePopupMenuItem00
static int tolua_CEGUI_CEGUI_MenuBase_changePopupMenuItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MenuBase",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::MenuItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MenuBase* self = (CEGUI::MenuBase*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MenuItem* item = ((CEGUI::MenuItem*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'changePopupMenuItem'",NULL);
#endif
 {
  self->changePopupMenuItem(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'changePopupMenuItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAllowMultiplePopups of class  CEGUI::MenuBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuBase_setAllowMultiplePopups00
static int tolua_CEGUI_CEGUI_MenuBase_setAllowMultiplePopups00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MenuBase",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MenuBase* self = (CEGUI::MenuBase*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAllowMultiplePopups'",NULL);
#endif
 {
  self->setAllowMultiplePopups(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAllowMultiplePopups'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getPopupMenuItem of class  CEGUI::MenuBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuBase_getPopupMenuItem01
static int tolua_CEGUI_CEGUI_MenuBase_getPopupMenuItem01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MenuBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::MenuBase* self = (const CEGUI::MenuBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPopupMenuItem'",NULL);
#endif
 {
  CEGUI::MenuItem* tolua_ret = (CEGUI::MenuItem*)  self->getPopupMenuItem();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::MenuItem");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_MenuBase_getPopupMenuItem00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFadeInTime of class  CEGUI::PopupMenu */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PopupMenu_getFadeInTime00
static int tolua_CEGUI_CEGUI_PopupMenu_getFadeInTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::PopupMenu",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PopupMenu* self = (const CEGUI::PopupMenu*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFadeInTime'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getFadeInTime();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFadeInTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFadeOutTime of class  CEGUI::PopupMenu */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PopupMenu_getFadeOutTime00
static int tolua_CEGUI_CEGUI_PopupMenu_getFadeOutTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::PopupMenu",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PopupMenu* self = (const CEGUI::PopupMenu*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFadeOutTime'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getFadeOutTime();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFadeOutTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFadeInTime of class  CEGUI::PopupMenu */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PopupMenu_setFadeInTime00
static int tolua_CEGUI_CEGUI_PopupMenu_setFadeInTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PopupMenu",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PopupMenu* self = (CEGUI::PopupMenu*)  tolua_tousertype(tolua_S,1,0);
  float fadetime = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFadeInTime'",NULL);
#endif
 {
  self->setFadeInTime(fadetime);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFadeInTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFadeOutTime of class  CEGUI::PopupMenu */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PopupMenu_setFadeOutTime00
static int tolua_CEGUI_CEGUI_PopupMenu_setFadeOutTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PopupMenu",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PopupMenu* self = (CEGUI::PopupMenu*)  tolua_tousertype(tolua_S,1,0);
  float fadetime = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFadeOutTime'",NULL);
#endif
 {
  self->setFadeOutTime(fadetime);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFadeOutTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: openPopupMenu of class  CEGUI::PopupMenu */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PopupMenu_openPopupMenu00
static int tolua_CEGUI_CEGUI_PopupMenu_openPopupMenu00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PopupMenu",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PopupMenu* self = (CEGUI::PopupMenu*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'openPopupMenu'",NULL);
#endif
 {
  self->openPopupMenu();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'openPopupMenu'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: closePopupMenu of class  CEGUI::PopupMenu */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PopupMenu_closePopupMenu00
static int tolua_CEGUI_CEGUI_PopupMenu_closePopupMenu00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PopupMenu",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PopupMenu* self = (CEGUI::PopupMenu*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'closePopupMenu'",NULL);
#endif
 {
  self->closePopupMenu();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'closePopupMenu'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: getPopupMenu of class  CEGUI::MenuItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuItem_getPopupMenu00
static int tolua_CEGUI_CEGUI_MenuItem_getPopupMenu00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MenuItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MenuItem* self = (const CEGUI::MenuItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPopupMenu'",NULL);
#endif
 {
  CEGUI::PopupMenu* tolua_ret = (CEGUI::PopupMenu*)  self->getPopupMenu();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::PopupMenu");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPopupMenu'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPopupMenu of class  CEGUI::MenuItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuItem_setPopupMenu00
static int tolua_CEGUI_CEGUI_MenuItem_setPopupMenu00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MenuItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::PopupMenu",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MenuItem* self = (CEGUI::MenuItem*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::PopupMenu* popup = ((CEGUI::PopupMenu*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPopupMenu'",NULL);
#endif
 {
  self->setPopupMenu(popup);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPopupMenu'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: openPopupMenu of class  CEGUI::MenuItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuItem_openPopupMenu00
static int tolua_CEGUI_CEGUI_MenuItem_openPopupMenu00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MenuItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MenuItem* self = (CEGUI::MenuItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'openPopupMenu'",NULL);
#endif
 {
  self->openPopupMenu();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'openPopupMenu'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: closePopupMenu of class  CEGUI::MenuItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuItem_closePopupMenu00
static int tolua_CEGUI_CEGUI_MenuItem_closePopupMenu00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MenuItem",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MenuItem* self = (CEGUI::MenuItem*)  tolua_tousertype(tolua_S,1,0);
  bool notify = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'closePopupMenu'",NULL);
#endif
 {
  self->closePopupMenu(notify);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'closePopupMenu'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: getAutoPopupTimeout of class  CEGUI::MenuItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuItem_getAutoPopupTimeout00
static int tolua_CEGUI_CEGUI_MenuItem_getAutoPopupTimeout00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MenuItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MenuItem* self = (const CEGUI::MenuItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAutoPopupTimeout'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getAutoPopupTimeout();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAutoPopupTimeout'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAutoPopupTimeout of class  CEGUI::MenuItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuItem_setAutoPopupTimeout00
static int tolua_CEGUI_CEGUI_MenuItem_setAutoPopupTimeout00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MenuItem",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MenuItem* self = (CEGUI::MenuItem*)  tolua_tousertype(tolua_S,1,0);
  float time = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoPopupTimeout'",NULL);
#endif
 {
  self->setAutoPopupTimeout(time);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoPopupTimeout'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPopupOffset of class  CEGUI::MenuItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuItem_getPopupOffset00
static int tolua_CEGUI_CEGUI_MenuItem_getPopupOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::MenuItem",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::MenuItem* self = (const CEGUI::MenuItem*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPopupOffset'",NULL);
#endif
 {
  const CEGUI::UVector2& tolua_ret = (const CEGUI::UVector2&)  self->getPopupOffset();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::UVector2");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPopupOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPopupOffset of class  CEGUI::MenuItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MenuItem_setPopupOffset00
static int tolua_CEGUI_CEGUI_MenuItem_setPopupOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::MenuItem",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MenuItem* self = (CEGUI::MenuItem*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* popupOffset = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPopupOffset'",NULL);
#endif
 {
  self->setPopupOffset(*popupOffset);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPopupOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: getVertScrollbar of class  CEGUI::ScrolledItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrolledItemListBase_getVertScrollbar00
static int tolua_CEGUI_CEGUI_ScrolledItemListBase_getVertScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrolledItemListBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrolledItemListBase* self = (const CEGUI::ScrolledItemListBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVertScrollbar'",NULL);
#endif
 {
  CEGUI::Scrollbar* tolua_ret = (CEGUI::Scrollbar*)  self->getVertScrollbar();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Scrollbar");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVertScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHorzScrollbar of class  CEGUI::ScrolledItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrolledItemListBase_getHorzScrollbar00
static int tolua_CEGUI_CEGUI_ScrolledItemListBase_getHorzScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ScrolledItemListBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ScrolledItemListBase* self = (const CEGUI::ScrolledItemListBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHorzScrollbar'",NULL);
#endif
 {
  CEGUI::Scrollbar* tolua_ret = (CEGUI::Scrollbar*)  self->getHorzScrollbar();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Scrollbar");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorzScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setShowVertScrollbar of class  CEGUI::ScrolledItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrolledItemListBase_setShowVertScrollbar00
static int tolua_CEGUI_CEGUI_ScrolledItemListBase_setShowVertScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrolledItemListBase",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrolledItemListBase* self = (CEGUI::ScrolledItemListBase*)  tolua_tousertype(tolua_S,1,0);
  bool mode = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShowVertScrollbar'",NULL);
#endif
 {
  self->setShowVertScrollbar(mode);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShowVertScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setShowHorzScrollbar of class  CEGUI::ScrolledItemListBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ScrolledItemListBase_setShowHorzScrollbar00
static int tolua_CEGUI_CEGUI_ScrolledItemListBase_setShowHorzScrollbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ScrolledItemListBase",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ScrolledItemListBase* self = (CEGUI::ScrolledItemListBase*)  tolua_tousertype(tolua_S,1,0);
  bool mode = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setShowHorzScrollbar'",NULL);
#endif
 {
  self->setShowHorzScrollbar(mode);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setShowHorzScrollbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSelectedCount of class  CEGUI::ItemListbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListbox_getSelectedCount00
static int tolua_CEGUI_CEGUI_ItemListbox_getSelectedCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemListbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemListbox* self = (const CEGUI::ItemListbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSelectedCount'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getSelectedCount();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSelectedCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLastSelectedItem of class  CEGUI::ItemListbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListbox_getLastSelectedItem00
static int tolua_CEGUI_CEGUI_ItemListbox_getLastSelectedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemListbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemListbox* self = (const CEGUI::ItemListbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLastSelectedItem'",NULL);
#endif
 {
  CEGUI::ItemEntry* tolua_ret = (CEGUI::ItemEntry*)  self->getLastSelectedItem();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ItemEntry");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLastSelectedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFirstSelectedItem of class  CEGUI::ItemListbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListbox_getFirstSelectedItem00
static int tolua_CEGUI_CEGUI_ItemListbox_getFirstSelectedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemListbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemListbox* self = (const CEGUI::ItemListbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long start_index = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFirstSelectedItem'",NULL);
#endif
 {
  CEGUI::ItemEntry* tolua_ret = (CEGUI::ItemEntry*)  self->getFirstSelectedItem(start_index);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ItemEntry");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFirstSelectedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNextSelectedItem of class  CEGUI::ItemListbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListbox_getNextSelectedItem00
static int tolua_CEGUI_CEGUI_ItemListbox_getNextSelectedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemListbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemListbox* self = (const CEGUI::ItemListbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNextSelectedItem'",NULL);
#endif
 {
  CEGUI::ItemEntry* tolua_ret = (CEGUI::ItemEntry*)  self->getNextSelectedItem();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ItemEntry");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNextSelectedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNextSelectedItemAfter of class  CEGUI::ItemListbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListbox_getNextSelectedItemAfter00
static int tolua_CEGUI_CEGUI_ItemListbox_getNextSelectedItemAfter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemListbox",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ItemEntry",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemListbox* self = (const CEGUI::ItemListbox*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ItemEntry* start_item = ((const CEGUI::ItemEntry*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNextSelectedItemAfter'",NULL);
#endif
 {
  CEGUI::ItemEntry* tolua_ret = (CEGUI::ItemEntry*)  self->getNextSelectedItemAfter(start_item);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ItemEntry");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNextSelectedItemAfter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: isItemSelected of class  CEGUI::ItemListbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListbox_isItemSelected00
static int tolua_CEGUI_CEGUI_ItemListbox_isItemSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ItemListbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ItemListbox* self = (const CEGUI::ItemListbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long index = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isItemSelected'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isItemSelected(index);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isItemSelected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMultiSelectEnabled of class  CEGUI::ItemListbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListbox_setMultiSelectEnabled00
static int tolua_CEGUI_CEGUI_ItemListbox_setMultiSelectEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListbox",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListbox* self = (CEGUI::ItemListbox*)  tolua_tousertype(tolua_S,1,0);
  bool state = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMultiSelectEnabled'",NULL);
#endif
 {
  self->setMultiSelectEnabled(state);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMultiSelectEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearAllSelections of class  CEGUI::ItemListbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListbox_clearAllSelections00
static int tolua_CEGUI_CEGUI_ItemListbox_clearAllSelections00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListbox* self = (CEGUI::ItemListbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearAllSelections'",NULL);
#endif
 {
  self->clearAllSelections();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearAllSelections'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: selectRange of class  CEGUI::ItemListbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListbox_selectRange00
static int tolua_CEGUI_CEGUI_ItemListbox_selectRange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListbox",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListbox* self = (CEGUI::ItemListbox*)  tolua_tousertype(tolua_S,1,0);
  unsigned long a = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
  unsigned long z = ((unsigned long)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'selectRange'",NULL);
#endif
 {
  self->selectRange(a,z);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'selectRange'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: selectAllItems of class  CEGUI::ItemListbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ItemListbox_selectAllItems00
static int tolua_CEGUI_CEGUI_ItemListbox_selectAllItems00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ItemListbox",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ItemListbox* self = (CEGUI::ItemListbox*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'selectAllItems'",NULL);
#endif
 {
  self->selectAllItems();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'selectAllItems'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: drawAroundWidget of class  CEGUI::GroupBox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GroupBox_drawAroundWidget00
static int tolua_CEGUI_CEGUI_GroupBox_drawAroundWidget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GroupBox",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GroupBox* self = (CEGUI::GroupBox*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'drawAroundWidget'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->drawAroundWidget(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'drawAroundWidget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: markNeedsLayouting of class  CEGUI::LayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_LayoutContainer_markNeedsLayouting00
static int tolua_CEGUI_CEGUI_LayoutContainer_markNeedsLayouting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::LayoutContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::LayoutContainer* self = (CEGUI::LayoutContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'markNeedsLayouting'",NULL);
#endif
 {
  self->markNeedsLayouting();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'markNeedsLayouting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: layout of class  CEGUI::LayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_LayoutContainer_layout00
static int tolua_CEGUI_CEGUI_LayoutContainer_layout00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::LayoutContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::LayoutContainer* self = (CEGUI::LayoutContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'layout'",NULL);
#endif
 {
  self->layout();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'layout'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: layoutIfNecessary of class  CEGUI::LayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_LayoutContainer_layoutIfNecessary00
static int tolua_CEGUI_CEGUI_LayoutContainer_layoutIfNecessary00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::LayoutContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::LayoutContainer* self = (CEGUI::LayoutContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'layoutIfNecessary'",NULL);
#endif
 {
  self->layoutIfNecessary();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'layoutIfNecessary'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPositionOfChildWindow of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChildWindow00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChildWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SequentialLayoutContainer* self = (const CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPositionOfChildWindow'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getPositionOfChildWindow(wnd);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPositionOfChildWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPositionOfChildWindow of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChildWindow01
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChildWindow01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::SequentialLayoutContainer* self = (const CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  utf8string wnd = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPositionOfChildWindow'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getPositionOfChildWindow(wnd);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChildWindow00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildWindowAtPosition of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_getChildWindowAtPosition00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_getChildWindowAtPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SequentialLayoutContainer* self = (const CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  unsigned int position = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getChildWindowAtPosition'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getChildWindowAtPosition(position);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getChildWindowAtPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildWindowPositions of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindowPositions00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindowPositions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SequentialLayoutContainer* self = (CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  unsigned int wnd1 = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int wnd2 = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'swapChildWindowPositions'",NULL);
#endif
 {
  self->swapChildWindowPositions(wnd1,wnd2);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'swapChildWindowPositions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildWindows of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",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
 {
  CEGUI::SequentialLayoutContainer* self = (CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* wnd1 = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* wnd2 = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'swapChildWindows'",NULL);
#endif
 {
  self->swapChildWindows(wnd1,wnd2);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'swapChildWindows'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildWindows of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows01
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::SequentialLayoutContainer* self = (CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  utf8string wnd1 = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::Window* wnd2 = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'swapChildWindows'",NULL);
#endif
 {
  self->swapChildWindows(wnd1,wnd2);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildWindows of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows02
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::SequentialLayoutContainer* self = (CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* wnd1 = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  utf8string wnd2 = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'swapChildWindows'",NULL);
#endif
 {
  self->swapChildWindows(wnd1,wnd2);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildWindows of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows03
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::SequentialLayoutContainer* self = (CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  utf8string wnd1 = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string wnd2 = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'swapChildWindows'",NULL);
#endif
 {
  self->swapChildWindows(wnd1,wnd2);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveChildWindowToPosition of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildWindowToPosition00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildWindowToPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SequentialLayoutContainer* self = (CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  unsigned int position = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveChildWindowToPosition'",NULL);
#endif
 {
  self->moveChildWindowToPosition(wnd,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveChildWindowToPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveChildWindowToPosition of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildWindowToPosition01
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildWindowToPosition01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::SequentialLayoutContainer* self = (CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  utf8string wnd = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  unsigned int position = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveChildWindowToPosition'",NULL);
#endif
 {
  self->moveChildWindowToPosition(wnd,position);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildWindowToPosition00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveChildWindow of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildWindow00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SequentialLayoutContainer* self = (CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* window = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  int delta = ((int)  tolua_tonumber(tolua_S,3,1));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveChildWindow'",NULL);
#endif
 {
  self->moveChildWindow(window,delta);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveChildWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addChildWindowToPosition of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_addChildWindowToPosition00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_addChildWindowToPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SequentialLayoutContainer* self = (CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* window = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  unsigned int position = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addChildWindowToPosition'",NULL);
#endif
 {
  self->addChildWindowToPosition(window,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addChildWindowToPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addChildWindowToPosition of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_addChildWindowToPosition01
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_addChildWindowToPosition01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::SequentialLayoutContainer* self = (CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  utf8string window = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  unsigned int position = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addChildWindowToPosition'",NULL);
#endif
 {
  self->addChildWindowToPosition(window,position);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SequentialLayoutContainer_addChildWindowToPosition00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeChildWindowFromPosition of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_removeChildWindowFromPosition00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_removeChildWindowFromPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SequentialLayoutContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SequentialLayoutContainer* self = (CEGUI::SequentialLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  unsigned int position = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeChildWindowFromPosition'",NULL);
#endif
 {
  self->removeChildWindowFromPosition(position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeChildWindowFromPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setGridDimensions of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_setGridDimensions00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_setGridDimensions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  unsigned int width = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int height = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setGridDimensions'",NULL);
#endif
 {
  self->setGridDimensions(width,height);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setGridDimensions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getGridWidth of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_getGridWidth00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_getGridWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::GridLayoutContainer* self = (const CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getGridWidth'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getGridWidth();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getGridWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getGridHeight of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_getGridHeight00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_getGridHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::GridLayoutContainer* self = (const CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getGridHeight'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getGridHeight();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getGridHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAutoPositioning of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_setAutoPositioning00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_setAutoPositioning00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::GridLayoutContainer::AutoPositioning positioning = ((CEGUI::GridLayoutContainer::AutoPositioning) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoPositioning'",NULL);
#endif
 {
  self->setAutoPositioning(positioning);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoPositioning'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAutoPositioning of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_getAutoPositioning00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_getAutoPositioning00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::GridLayoutContainer* self = (const CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAutoPositioning'",NULL);
#endif
 {
  CEGUI::GridLayoutContainer::AutoPositioning tolua_ret = (CEGUI::GridLayoutContainer::AutoPositioning)  self->getAutoPositioning();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAutoPositioning'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setNextAutoPositioningIdx of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_setNextAutoPositioningIdx00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_setNextAutoPositioningIdx00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  unsigned int idx = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNextAutoPositioningIdx'",NULL);
#endif
 {
  self->setNextAutoPositioningIdx(idx);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNextAutoPositioningIdx'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNextAutoPositioningIdx of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_getNextAutoPositioningIdx00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_getNextAutoPositioningIdx00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::GridLayoutContainer* self = (const CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNextAutoPositioningIdx'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getNextAutoPositioningIdx();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNextAutoPositioningIdx'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: autoPositioningSkipCells of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_autoPositioningSkipCells00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_autoPositioningSkipCells00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  unsigned int cells = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'autoPositioningSkipCells'",NULL);
#endif
 {
  self->autoPositioningSkipCells(cells);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'autoPositioningSkipCells'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addChildWindowToPosition of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_addChildWindowToPosition00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_addChildWindowToPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* window = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  unsigned int gridX = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  unsigned int gridY = ((unsigned int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addChildWindowToPosition'",NULL);
#endif
 {
  self->addChildWindowToPosition(window,gridX,gridY);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addChildWindowToPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addChildWindowToPosition of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_addChildWindowToPosition01
static int tolua_CEGUI_CEGUI_GridLayoutContainer_addChildWindowToPosition01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  unsigned int gridX = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  unsigned int gridY = ((unsigned int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addChildWindowToPosition'",NULL);
#endif
 {
  self->addChildWindowToPosition(name,gridX,gridY);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_GridLayoutContainer_addChildWindowToPosition00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildWindowAtPosition of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_getChildWindowAtPosition00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_getChildWindowAtPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  unsigned int gridX = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int gridY = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getChildWindowAtPosition'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getChildWindowAtPosition(gridX,gridY);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getChildWindowAtPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeChildWindowFromPosition of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_removeChildWindowFromPosition00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_removeChildWindowFromPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  unsigned int gridX = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int gridY = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeChildWindowFromPosition'",NULL);
#endif
 {
  self->removeChildWindowFromPosition(gridX,gridY);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeChildWindowFromPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildWindowPositions of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindowPositions00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindowPositions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  unsigned int wnd1 = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int wnd2 = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'swapChildWindowPositions'",NULL);
#endif
 {
  self->swapChildWindowPositions(wnd1,wnd2);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'swapChildWindowPositions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildWindowPositions of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindowPositions01
static int tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindowPositions01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  unsigned int gridX1 = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int gridY1 = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  unsigned int gridX2 = ((unsigned int)  tolua_tonumber(tolua_S,4,0));
  unsigned int gridY2 = ((unsigned int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'swapChildWindowPositions'",NULL);
#endif
 {
  self->swapChildWindowPositions(gridX1,gridY1,gridX2,gridY2);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindowPositions00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildWindows of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindows00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindows00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",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
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* wnd1 = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Window* wnd2 = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'swapChildWindows'",NULL);
#endif
 {
  self->swapChildWindows(wnd1,wnd2);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'swapChildWindows'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildWindows of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindows01
static int tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindows01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* wnd1 = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  utf8string wnd2 = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'swapChildWindows'",NULL);
#endif
 {
  self->swapChildWindows(wnd1,wnd2);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindows00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildWindows of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindows02
static int tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindows02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  utf8string wnd1 = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::Window* wnd2 = ((CEGUI::Window*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'swapChildWindows'",NULL);
#endif
 {
  self->swapChildWindows(wnd1,wnd2);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindows01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveChildWindowToPosition of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildWindowToPosition00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildWindowToPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  unsigned int gridX = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  unsigned int gridY = ((unsigned int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveChildWindowToPosition'",NULL);
#endif
 {
  self->moveChildWindowToPosition(wnd,gridX,gridY);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveChildWindowToPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveChildWindowToPosition of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildWindowToPosition01
static int tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildWindowToPosition01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GridLayoutContainer",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::GridLayoutContainer* self = (CEGUI::GridLayoutContainer*)  tolua_tousertype(tolua_S,1,0);
  utf8string wnd = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  unsigned int gridX = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  unsigned int gridY = ((unsigned int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveChildWindowToPosition'",NULL);
#endif
 {
  self->moveChildWindowToPosition(wnd,gridX,gridY);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildWindowToPosition00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getValue of class  CEGUI::BaseDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_BaseDim_getValue00
static int tolua_CEGUI_CEGUI_BaseDim_getValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::BaseDim* self = (const CEGUI::BaseDim*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* wnd = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValue'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  float tolua_ret = (float)  self->getValue(*wnd);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
catch(CEGUI::InvalidRequestException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::InvalidRequestException' was thrown by function 'getValue'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 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: getValue of class  CEGUI::BaseDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_BaseDim_getValue01
static int tolua_CEGUI_CEGUI_BaseDim_getValue01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::BaseDim* self = (const CEGUI::BaseDim*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* wnd = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Rect* container = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValue'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  float tolua_ret = (float)  self->getValue(*wnd,*container);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
catch(CEGUI::InvalidRequestException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::InvalidRequestException' was thrown by function 'getValue'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_BaseDim_getValue00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: clone of class  CEGUI::BaseDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_BaseDim_clone00
static int tolua_CEGUI_CEGUI_BaseDim_clone00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::BaseDim* self = (const CEGUI::BaseDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clone'",NULL);
#endif
 {
  CEGUI::BaseDim* tolua_ret = (CEGUI::BaseDim*)  self->clone();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::BaseDim");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clone'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDimensionOperator of class  CEGUI::BaseDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_BaseDim_getDimensionOperator00
static int tolua_CEGUI_CEGUI_BaseDim_getDimensionOperator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::BaseDim* self = (const CEGUI::BaseDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDimensionOperator'",NULL);
#endif
 {
  CEGUI::DimensionOperator tolua_ret = (CEGUI::DimensionOperator)  self->getDimensionOperator();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDimensionOperator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDimensionOperator of class  CEGUI::BaseDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_BaseDim_setDimensionOperator00
static int tolua_CEGUI_CEGUI_BaseDim_setDimensionOperator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::BaseDim* self = (CEGUI::BaseDim*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::DimensionOperator op = ((CEGUI::DimensionOperator) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDimensionOperator'",NULL);
#endif
 {
  self->setDimensionOperator(op);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDimensionOperator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOperand of class  CEGUI::BaseDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_BaseDim_getOperand00
static int tolua_CEGUI_CEGUI_BaseDim_getOperand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::BaseDim* self = (const CEGUI::BaseDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOperand'",NULL);
#endif
 {
  const CEGUI::BaseDim* tolua_ret = (const CEGUI::BaseDim*)  self->getOperand();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::BaseDim");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOperand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setOperand of class  CEGUI::BaseDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_BaseDim_setOperand00
static int tolua_CEGUI_CEGUI_BaseDim_setOperand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::BaseDim* self = (CEGUI::BaseDim*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::BaseDim* operand = ((const CEGUI::BaseDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOperand'",NULL);
#endif
 {
  self->setOperand(*operand);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setOperand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setValue of class  CEGUI::AbsoluteDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AbsoluteDim_setValue00
static int tolua_CEGUI_CEGUI_AbsoluteDim_setValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::AbsoluteDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AbsoluteDim* self = (CEGUI::AbsoluteDim*)  tolua_tousertype(tolua_S,1,0);
  float val = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValue'",NULL);
#endif
 {
  self->setValue(val);
 }
 }
 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: new of class  CEGUI::AbsoluteDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AbsoluteDim_new00
static int tolua_CEGUI_CEGUI_AbsoluteDim_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::AbsoluteDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  float val = ((float)  tolua_tonumber(tolua_S,2,0));
 {
  CEGUI::AbsoluteDim* tolua_ret = (CEGUI::AbsoluteDim*)  new CEGUI::AbsoluteDim(val);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::AbsoluteDim");
 }
 }
 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  CEGUI::AbsoluteDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AbsoluteDim_new00_local
static int tolua_CEGUI_CEGUI_AbsoluteDim_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::AbsoluteDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  float val = ((float)  tolua_tonumber(tolua_S,2,0));
 {
  CEGUI::AbsoluteDim* tolua_ret = (CEGUI::AbsoluteDim*)  new CEGUI::AbsoluteDim(val);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::AbsoluteDim");
 }
 }
 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: setSourceImage of class  CEGUI::ImageDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageDim_setSourceImage00
static int tolua_CEGUI_CEGUI_ImageDim_setSourceImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageDim* self = (CEGUI::ImageDim*)  tolua_tousertype(tolua_S,1,0);
  utf8string imageset = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string image = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSourceImage'",NULL);
#endif
 {
  self->setSourceImage(imageset,image);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSourceImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSourceDimension of class  CEGUI::ImageDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageDim_setSourceDimension00
static int tolua_CEGUI_CEGUI_ImageDim_setSourceDimension00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageDim* self = (CEGUI::ImageDim*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::DimensionType dim = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSourceDimension'",NULL);
#endif
 {
  self->setSourceDimension(dim);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSourceDimension'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::ImageDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageDim_new00
static int tolua_CEGUI_CEGUI_ImageDim_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImageDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string imageset = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string image = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  CEGUI::DimensionType dim = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,4,0));
 {
  CEGUI::ImageDim* tolua_ret = (CEGUI::ImageDim*)  new CEGUI::ImageDim(imageset,image,dim);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ImageDim");
 }
 }
 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  CEGUI::ImageDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageDim_new00_local
static int tolua_CEGUI_CEGUI_ImageDim_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImageDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string imageset = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string image = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  CEGUI::DimensionType dim = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,4,0));
 {
  CEGUI::ImageDim* tolua_ret = (CEGUI::ImageDim*)  new CEGUI::ImageDim(imageset,image,dim);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::ImageDim");
 }
 }
 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: setWidgetName of class  CEGUI::WidgetDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetDim_setWidgetName00
static int tolua_CEGUI_CEGUI_WidgetDim_setWidgetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetDim* self = (CEGUI::WidgetDim*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWidgetName'",NULL);
#endif
 {
  self->setWidgetName(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWidgetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setSourceDimension of class  CEGUI::WidgetDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetDim_setSourceDimension00
static int tolua_CEGUI_CEGUI_WidgetDim_setSourceDimension00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetDim* self = (CEGUI::WidgetDim*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::DimensionType dim = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setSourceDimension'",NULL);
#endif
 {
  self->setSourceDimension(dim);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSourceDimension'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::WidgetDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetDim_new00
static int tolua_CEGUI_CEGUI_WidgetDim_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::DimensionType dim = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::WidgetDim* tolua_ret = (CEGUI::WidgetDim*)  new CEGUI::WidgetDim(name,dim);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::WidgetDim");
 }
 }
 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  CEGUI::WidgetDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetDim_new00_local
static int tolua_CEGUI_CEGUI_WidgetDim_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::DimensionType dim = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::WidgetDim* tolua_ret = (CEGUI::WidgetDim*)  new CEGUI::WidgetDim(name,dim);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::WidgetDim");
 }
 }
 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 of class  CEGUI::UnifiedDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UnifiedDim_new00
static int tolua_CEGUI_CEGUI_UnifiedDim_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UnifiedDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UDim* value = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::DimensionType dim = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::UnifiedDim* tolua_ret = (CEGUI::UnifiedDim*)  new CEGUI::UnifiedDim(*value,dim);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::UnifiedDim");
 }
 }
 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  CEGUI::UnifiedDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UnifiedDim_new00_local
static int tolua_CEGUI_CEGUI_UnifiedDim_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::UnifiedDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UDim* value = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::DimensionType dim = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::UnifiedDim* tolua_ret = (CEGUI::UnifiedDim*)  new CEGUI::UnifiedDim(*value,dim);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::UnifiedDim");
 }
 }
 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 of class  CEGUI::FontDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontDim_new00
static int tolua_CEGUI_CEGUI_FontDim_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::FontDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string font = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,4,0));
  CEGUI::FontMetricType metric = ((CEGUI::FontMetricType) (int)  tolua_tonumber(tolua_S,5,0));
  float padding = ((float)  tolua_tonumber(tolua_S,6,0));
 {
  CEGUI::FontDim* tolua_ret = (CEGUI::FontDim*)  new CEGUI::FontDim(name,font,text,metric,padding);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::FontDim");
 }
 }
 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  CEGUI::FontDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontDim_new00_local
static int tolua_CEGUI_CEGUI_FontDim_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::FontDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string font = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,4,0));
  CEGUI::FontMetricType metric = ((CEGUI::FontMetricType) (int)  tolua_tonumber(tolua_S,5,0));
  float padding = ((float)  tolua_tonumber(tolua_S,6,0));
 {
  CEGUI::FontDim* tolua_ret = (CEGUI::FontDim*)  new CEGUI::FontDim(name,font,text,metric,padding);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::FontDim");
 }
 }
 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 of class  CEGUI::PropertyDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyDim_new00
static int tolua_CEGUI_CEGUI_PropertyDim_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  CEGUI::DimensionType type = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,4,0));
 {
  CEGUI::PropertyDim* tolua_ret = (CEGUI::PropertyDim*)  new CEGUI::PropertyDim(name,property,type);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::PropertyDim");
 }
 }
 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  CEGUI::PropertyDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyDim_new00_local
static int tolua_CEGUI_CEGUI_PropertyDim_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  CEGUI::DimensionType type = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,4,0));
 {
  CEGUI::PropertyDim* tolua_ret = (CEGUI::PropertyDim*)  new CEGUI::PropertyDim(name,property,type);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::PropertyDim");
 }
 }
 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: getBaseDimension of class  CEGUI::Dimension */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Dimension_getBaseDimension00
static int tolua_CEGUI_CEGUI_Dimension_getBaseDimension00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Dimension",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Dimension* self = (const CEGUI::Dimension*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBaseDimension'",NULL);
#endif
 {
  const CEGUI::BaseDim& tolua_ret = (const CEGUI::BaseDim&)  self->getBaseDimension();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::BaseDim");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBaseDimension'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBaseDimension of class  CEGUI::Dimension */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Dimension_setBaseDimension00
static int tolua_CEGUI_CEGUI_Dimension_setBaseDimension00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Dimension",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Dimension* self = (CEGUI::Dimension*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::BaseDim* dim = ((const CEGUI::BaseDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBaseDimension'",NULL);
#endif
 {
  self->setBaseDimension(*dim);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBaseDimension'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDimensionType of class  CEGUI::Dimension */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Dimension_getDimensionType00
static int tolua_CEGUI_CEGUI_Dimension_getDimensionType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Dimension",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Dimension* self = (const CEGUI::Dimension*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDimensionType'",NULL);
#endif
 {
  CEGUI::DimensionType tolua_ret = (CEGUI::DimensionType)  self->getDimensionType();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDimensionType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDimensionType of class  CEGUI::Dimension */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Dimension_setDimensionType00
static int tolua_CEGUI_CEGUI_Dimension_setDimensionType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Dimension",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Dimension* self = (CEGUI::Dimension*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::DimensionType type = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDimensionType'",NULL);
#endif
 {
  self->setDimensionType(type);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDimensionType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::Dimension */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Dimension_new00
static int tolua_CEGUI_CEGUI_Dimension_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Dimension",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::BaseDim* dim = ((const CEGUI::BaseDim*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::DimensionType type = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::Dimension* tolua_ret = (CEGUI::Dimension*)  new CEGUI::Dimension(*dim,type);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Dimension");
 }
 }
 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  CEGUI::Dimension */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Dimension_new00_local
static int tolua_CEGUI_CEGUI_Dimension_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Dimension",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::BaseDim* dim = ((const CEGUI::BaseDim*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::DimensionType type = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::Dimension* tolua_ret = (CEGUI::Dimension*)  new CEGUI::Dimension(*dim,type);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Dimension");
 }
 }
 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 of class  CEGUI::Dimension */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Dimension_new01
static int tolua_CEGUI_CEGUI_Dimension_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Dimension",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Dimension",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Dimension* other = ((const CEGUI::Dimension*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::Dimension* tolua_ret = (CEGUI::Dimension*)  new CEGUI::Dimension(*other);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Dimension");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Dimension_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::Dimension */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Dimension_new01_local
static int tolua_CEGUI_CEGUI_Dimension_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Dimension",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Dimension",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Dimension* other = ((const CEGUI::Dimension*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::Dimension* tolua_ret = (CEGUI::Dimension*)  new CEGUI::Dimension(*other);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Dimension");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Dimension_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::Dimension */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Dimension_new02
static int tolua_CEGUI_CEGUI_Dimension_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Dimension",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
 {
  CEGUI::Dimension* tolua_ret = (CEGUI::Dimension*)  new CEGUI::Dimension();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Dimension");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Dimension_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::Dimension */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Dimension_new02_local
static int tolua_CEGUI_CEGUI_Dimension_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Dimension",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
 {
  CEGUI::Dimension* tolua_ret = (CEGUI::Dimension*)  new CEGUI::Dimension();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Dimension");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Dimension_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPixelRect of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ComponentArea_getPixelRect00
static int tolua_CEGUI_CEGUI_ComponentArea_getPixelRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ComponentArea",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ComponentArea* self = (const CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* wnd = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPixelRect'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getPixelRect(*wnd);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPixelRect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPixelRect of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ComponentArea_getPixelRect01
static int tolua_CEGUI_CEGUI_ComponentArea_getPixelRect01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ComponentArea",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::ComponentArea* self = (const CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* wnd = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Rect* container = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPixelRect'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getPixelRect(*wnd,*container);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ComponentArea_getPixelRect00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getAreaPropertySource of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ComponentArea_getAreaPropertySource00
static int tolua_CEGUI_CEGUI_ComponentArea_getAreaPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ComponentArea",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ComponentArea* self = (const CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAreaPropertySource'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getAreaPropertySource();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAreaPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAreaPropertySource of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ComponentArea_setAreaPropertySource00
static int tolua_CEGUI_CEGUI_ComponentArea_setAreaPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ComponentArea",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ComponentArea* self = (CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,1,0);
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAreaPropertySource'",NULL);
#endif
 {
  self->setAreaPropertySource(property);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAreaPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_left of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__ComponentArea_d_left
static int tolua_get_CEGUI__ComponentArea_d_left(lua_State* tolua_S)
{
  CEGUI::ComponentArea* self = (CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_left'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_left,"CEGUI::Dimension");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_left of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__ComponentArea_d_left
static int tolua_set_CEGUI__ComponentArea_d_left(lua_State* tolua_S)
{
  CEGUI::ComponentArea* self = (CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_left'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::Dimension",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_left = *((CEGUI::Dimension*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_top of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__ComponentArea_d_top
static int tolua_get_CEGUI__ComponentArea_d_top(lua_State* tolua_S)
{
  CEGUI::ComponentArea* self = (CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_top'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_top,"CEGUI::Dimension");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_top of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__ComponentArea_d_top
static int tolua_set_CEGUI__ComponentArea_d_top(lua_State* tolua_S)
{
  CEGUI::ComponentArea* self = (CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_top'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::Dimension",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_top = *((CEGUI::Dimension*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_right_or_width of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__ComponentArea_d_right_or_width
static int tolua_get_CEGUI__ComponentArea_d_right_or_width(lua_State* tolua_S)
{
  CEGUI::ComponentArea* self = (CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_right_or_width'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_right_or_width,"CEGUI::Dimension");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_right_or_width of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__ComponentArea_d_right_or_width
static int tolua_set_CEGUI__ComponentArea_d_right_or_width(lua_State* tolua_S)
{
  CEGUI::ComponentArea* self = (CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_right_or_width'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::Dimension",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_right_or_width = *((CEGUI::Dimension*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_bottom_or_height of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__ComponentArea_d_bottom_or_height
static int tolua_get_CEGUI__ComponentArea_d_bottom_or_height(lua_State* tolua_S)
{
  CEGUI::ComponentArea* self = (CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_bottom_or_height'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)&self->d_bottom_or_height,"CEGUI::Dimension");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_bottom_or_height of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__ComponentArea_d_bottom_or_height
static int tolua_set_CEGUI__ComponentArea_d_bottom_or_height(lua_State* tolua_S)
{
  CEGUI::ComponentArea* self = (CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'd_bottom_or_height'",NULL);
 if (!tolua_isusertype(tolua_S,2,"CEGUI::Dimension",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_bottom_or_height = *((CEGUI::Dimension*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ComponentArea_new00
static int tolua_CEGUI_CEGUI_ComponentArea_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ComponentArea",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::ComponentArea* tolua_ret = (CEGUI::ComponentArea*)  new CEGUI::ComponentArea();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ComponentArea");
 }
 }
 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  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ComponentArea_new00_local
static int tolua_CEGUI_CEGUI_ComponentArea_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ComponentArea",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::ComponentArea* tolua_ret = (CEGUI::ComponentArea*)  new CEGUI::ComponentArea();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::ComponentArea");
 }
 }
 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: getName of class  CEGUI::NamedArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedArea_getName00
static int tolua_CEGUI_CEGUI_NamedArea_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::NamedArea",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::NamedArea* self = (const CEGUI::NamedArea*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getArea of class  CEGUI::NamedArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedArea_getArea00
static int tolua_CEGUI_CEGUI_NamedArea_getArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::NamedArea",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::NamedArea* self = (const CEGUI::NamedArea*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getArea'",NULL);
#endif
 {
  const CEGUI::ComponentArea& tolua_ret = (const CEGUI::ComponentArea&)  self->getArea();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::ComponentArea");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setArea of class  CEGUI::NamedArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedArea_setArea00
static int tolua_CEGUI_CEGUI_NamedArea_setArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::NamedArea",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::ComponentArea",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::NamedArea* self = (CEGUI::NamedArea*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::ComponentArea area = *((CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setArea'",NULL);
#endif
 {
  self->setArea(area);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::NamedArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedArea_new00
static int tolua_CEGUI_CEGUI_NamedArea_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::NamedArea",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::NamedArea* tolua_ret = (CEGUI::NamedArea*)  new CEGUI::NamedArea();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::NamedArea");
 }
 }
 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  CEGUI::NamedArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedArea_new00_local
static int tolua_CEGUI_CEGUI_NamedArea_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::NamedArea",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::NamedArea* tolua_ret = (CEGUI::NamedArea*)  new CEGUI::NamedArea();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::NamedArea");
 }
 }
 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 of class  CEGUI::NamedArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedArea_new01
static int tolua_CEGUI_CEGUI_NamedArea_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::NamedArea",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::NamedArea* tolua_ret = (CEGUI::NamedArea*)  new CEGUI::NamedArea(name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::NamedArea");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_NamedArea_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::NamedArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedArea_new01_local
static int tolua_CEGUI_CEGUI_NamedArea_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::NamedArea",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::NamedArea* tolua_ret = (CEGUI::NamedArea*)  new CEGUI::NamedArea(name);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::NamedArea");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_NamedArea_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  CEGUI::PropertyDefinitionBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyDefinitionBase_set00
static int tolua_CEGUI_CEGUI_PropertyDefinitionBase_set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PropertyDefinitionBase",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PropertyDefinitionBase* self = (CEGUI::PropertyDefinitionBase*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* receiver = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  utf8string value = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(receiver,value);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: get of class  CEGUI::PropertyDefinition */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyDefinition_get00
static int tolua_CEGUI_CEGUI_PropertyDefinition_get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::PropertyDefinition",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PropertyDefinition* self = (const CEGUI::PropertyDefinition*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* receiver = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  string tolua_ret = (string)  self->get(receiver);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  CEGUI::PropertyDefinition */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyDefinition_set00
static int tolua_CEGUI_CEGUI_PropertyDefinition_set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PropertyDefinition",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PropertyDefinition* self = (CEGUI::PropertyDefinition*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* receiver = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  utf8string value = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(receiver,value);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::PropertyDefinition */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyDefinition_new00
static int tolua_CEGUI_CEGUI_PropertyDefinition_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyDefinition",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,4,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string initialValue = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  bool redrawOnWrite = ((bool)  tolua_toboolean(tolua_S,4,0));
  bool layoutOnWrite = ((bool)  tolua_toboolean(tolua_S,5,0));
 {
  CEGUI::PropertyDefinition* tolua_ret = (CEGUI::PropertyDefinition*)  new CEGUI::PropertyDefinition(name,initialValue,redrawOnWrite,layoutOnWrite);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::PropertyDefinition");
 }
 }
 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  CEGUI::PropertyDefinition */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyDefinition_new00_local
static int tolua_CEGUI_CEGUI_PropertyDefinition_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyDefinition",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,4,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string initialValue = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  bool redrawOnWrite = ((bool)  tolua_toboolean(tolua_S,4,0));
  bool layoutOnWrite = ((bool)  tolua_toboolean(tolua_S,5,0));
 {
  CEGUI::PropertyDefinition* tolua_ret = (CEGUI::PropertyDefinition*)  new CEGUI::PropertyDefinition(name,initialValue,redrawOnWrite,layoutOnWrite);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::PropertyDefinition");
 }
 }
 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: apply of class  CEGUI::PropertyInitialiser */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyInitialiser_apply00
static int tolua_CEGUI_CEGUI_PropertyInitialiser_apply00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::PropertyInitialiser",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PropertyInitialiser* self = (const CEGUI::PropertyInitialiser*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* target = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'apply'",NULL);
#endif
 {
  self->apply(*target);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'apply'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTargetPropertyName of class  CEGUI::PropertyInitialiser */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyInitialiser_getTargetPropertyName00
static int tolua_CEGUI_CEGUI_PropertyInitialiser_getTargetPropertyName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::PropertyInitialiser",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PropertyInitialiser* self = (const CEGUI::PropertyInitialiser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTargetPropertyName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getTargetPropertyName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTargetPropertyName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getInitialiserValue of class  CEGUI::PropertyInitialiser */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyInitialiser_getInitialiserValue00
static int tolua_CEGUI_CEGUI_PropertyInitialiser_getInitialiserValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::PropertyInitialiser",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PropertyInitialiser* self = (const CEGUI::PropertyInitialiser*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getInitialiserValue'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getInitialiserValue();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInitialiserValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::PropertyInitialiser */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyInitialiser_new00
static int tolua_CEGUI_CEGUI_PropertyInitialiser_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyInitialiser",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string value = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
 {
  CEGUI::PropertyInitialiser* tolua_ret = (CEGUI::PropertyInitialiser*)  new CEGUI::PropertyInitialiser(property,value);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::PropertyInitialiser");
 }
 }
 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  CEGUI::PropertyInitialiser */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyInitialiser_new00_local
static int tolua_CEGUI_CEGUI_PropertyInitialiser_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyInitialiser",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string value = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
 {
  CEGUI::PropertyInitialiser* tolua_ret = (CEGUI::PropertyInitialiser*)  new CEGUI::PropertyInitialiser(property,value);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::PropertyInitialiser");
 }
 }
 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: get of class  CEGUI::PropertyLinkDefinition */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyLinkDefinition_get00
static int tolua_CEGUI_CEGUI_PropertyLinkDefinition_get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::PropertyLinkDefinition",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PropertyLinkDefinition* self = (const CEGUI::PropertyLinkDefinition*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* receiver = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  string tolua_ret = (string)  self->get(receiver);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: set of class  CEGUI::PropertyLinkDefinition */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyLinkDefinition_set00
static int tolua_CEGUI_CEGUI_PropertyLinkDefinition_set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PropertyLinkDefinition",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PropertyLinkDefinition* self = (CEGUI::PropertyLinkDefinition*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* receiver = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  utf8string value = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'set'",NULL);
#endif
 {
  self->set(receiver,value);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::PropertyLinkDefinition */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyLinkDefinition_new00
static int tolua_CEGUI_CEGUI_PropertyLinkDefinition_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyLinkDefinition",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,5,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,6,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,7,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string propertyName = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string widgetNameSuffix = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  utf8string targetProperty = ((utf8string)  tolua_toutf8string(tolua_S,4,0));
  utf8string initialValue = ((utf8string)  tolua_toutf8string(tolua_S,5,0));
  bool redrawOnWrite = ((bool)  tolua_toboolean(tolua_S,6,0));
  bool layoutOnWrite = ((bool)  tolua_toboolean(tolua_S,7,0));
 {
  CEGUI::PropertyLinkDefinition* tolua_ret = (CEGUI::PropertyLinkDefinition*)  new CEGUI::PropertyLinkDefinition(propertyName,widgetNameSuffix,targetProperty,initialValue,redrawOnWrite,layoutOnWrite);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::PropertyLinkDefinition");
 }
 }
 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  CEGUI::PropertyLinkDefinition */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyLinkDefinition_new00_local
static int tolua_CEGUI_CEGUI_PropertyLinkDefinition_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::PropertyLinkDefinition",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,5,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,6,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,7,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string propertyName = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string widgetNameSuffix = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  utf8string targetProperty = ((utf8string)  tolua_toutf8string(tolua_S,4,0));
  utf8string initialValue = ((utf8string)  tolua_toutf8string(tolua_S,5,0));
  bool redrawOnWrite = ((bool)  tolua_toboolean(tolua_S,6,0));
  bool layoutOnWrite = ((bool)  tolua_toboolean(tolua_S,7,0));
 {
  CEGUI::PropertyLinkDefinition* tolua_ret = (CEGUI::PropertyLinkDefinition*)  new CEGUI::PropertyLinkDefinition(propertyName,widgetNameSuffix,targetProperty,initialValue,redrawOnWrite,layoutOnWrite);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::PropertyLinkDefinition");
 }
 }
 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: render of class  CEGUI::FalagardComponentBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardComponentBase_render00
static int tolua_CEGUI_CEGUI_FalagardComponentBase_render00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FalagardComponentBase",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::Rect",1,&tolua_err) ||
 !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FalagardComponentBase* self = (const CEGUI::FalagardComponentBase*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* srcWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::ColourRect* modColours = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Rect* clipper = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,4,0));
  bool clipToDisplay = ((bool)  tolua_toboolean(tolua_S,5,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*srcWindow,modColours,clipper,clipToDisplay);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'render'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  CEGUI::FalagardComponentBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardComponentBase_render01
static int tolua_CEGUI_CEGUI_FalagardComponentBase_render01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FalagardComponentBase",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::Rect",1,&tolua_err) ||
 !tolua_isboolean(tolua_S,6,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::FalagardComponentBase* self = (const CEGUI::FalagardComponentBase*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* srcWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Rect* baseRect = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::ColourRect* modColours = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Rect* clipper = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,5,0));
  bool clipToDisplay = ((bool)  tolua_toboolean(tolua_S,6,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*srcWindow,*baseRect,modColours,clipper,clipToDisplay);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_FalagardComponentBase_render00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getComponentArea of class  CEGUI::FalagardComponentBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardComponentBase_getComponentArea00
static int tolua_CEGUI_CEGUI_FalagardComponentBase_getComponentArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FalagardComponentBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FalagardComponentBase* self = (const CEGUI::FalagardComponentBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getComponentArea'",NULL);
#endif
 {
  const CEGUI::ComponentArea& tolua_ret = (const CEGUI::ComponentArea&)  self->getComponentArea();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::ComponentArea");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getComponentArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setComponentArea of class  CEGUI::FalagardComponentBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardComponentBase_setComponentArea00
static int tolua_CEGUI_CEGUI_FalagardComponentBase_setComponentArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FalagardComponentBase",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ComponentArea",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FalagardComponentBase* self = (CEGUI::FalagardComponentBase*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ComponentArea* area = ((const CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setComponentArea'",NULL);
#endif
 {
  self->setComponentArea(*area);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setComponentArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getColours of class  CEGUI::FalagardComponentBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardComponentBase_getColours00
static int tolua_CEGUI_CEGUI_FalagardComponentBase_getColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FalagardComponentBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FalagardComponentBase* self = (const CEGUI::FalagardComponentBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getColours'",NULL);
#endif
 {
  const CEGUI::ColourRect& tolua_ret = (const CEGUI::ColourRect&)  self->getColours();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::ColourRect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setColours of class  CEGUI::FalagardComponentBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardComponentBase_setColours00
static int tolua_CEGUI_CEGUI_FalagardComponentBase_setColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FalagardComponentBase",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FalagardComponentBase* self = (CEGUI::FalagardComponentBase*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ColourRect* cols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setColours'",NULL);
#endif
 {
  self->setColours(*cols);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setColoursPropertySource of class  CEGUI::FalagardComponentBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardComponentBase_setColoursPropertySource00
static int tolua_CEGUI_CEGUI_FalagardComponentBase_setColoursPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FalagardComponentBase",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FalagardComponentBase* self = (CEGUI::FalagardComponentBase*)  tolua_tousertype(tolua_S,1,0);
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setColoursPropertySource'",NULL);
#endif
 {
  self->setColoursPropertySource(property);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setColoursPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setColoursPropertyIsColourRect of class  CEGUI::FalagardComponentBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardComponentBase_setColoursPropertyIsColourRect00
static int tolua_CEGUI_CEGUI_FalagardComponentBase_setColoursPropertyIsColourRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FalagardComponentBase",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FalagardComponentBase* self = (CEGUI::FalagardComponentBase*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setColoursPropertyIsColourRect'",NULL);
#endif
 {
  self->setColoursPropertyIsColourRect(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setColoursPropertyIsColourRect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVertFormattingPropertySource of class  CEGUI::FalagardComponentBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardComponentBase_setVertFormattingPropertySource00
static int tolua_CEGUI_CEGUI_FalagardComponentBase_setVertFormattingPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FalagardComponentBase",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FalagardComponentBase* self = (CEGUI::FalagardComponentBase*)  tolua_tousertype(tolua_S,1,0);
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVertFormattingPropertySource'",NULL);
#endif
 {
  self->setVertFormattingPropertySource(property);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVertFormattingPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHorzFormattingPropertySource of class  CEGUI::FalagardComponentBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FalagardComponentBase_setHorzFormattingPropertySource00
static int tolua_CEGUI_CEGUI_FalagardComponentBase_setHorzFormattingPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FalagardComponentBase",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FalagardComponentBase* self = (CEGUI::FalagardComponentBase*)  tolua_tousertype(tolua_S,1,0);
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHorzFormattingPropertySource'",NULL);
#endif
 {
  self->setHorzFormattingPropertySource(property);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHorzFormattingPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBackgroundVerticalFormatting of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_getBackgroundVerticalFormatting00
static int tolua_CEGUI_CEGUI_FrameComponent_getBackgroundVerticalFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FrameComponent* self = (const CEGUI::FrameComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBackgroundVerticalFormatting'",NULL);
#endif
 {
  CEGUI::VerticalFormatting tolua_ret = (CEGUI::VerticalFormatting)  self->getBackgroundVerticalFormatting();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBackgroundVerticalFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBackgroundVerticalFormatting of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setBackgroundVerticalFormatting00
static int tolua_CEGUI_CEGUI_FrameComponent_setBackgroundVerticalFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FrameComponent* self = (CEGUI::FrameComponent*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::VerticalFormatting fmt = ((CEGUI::VerticalFormatting) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBackgroundVerticalFormatting'",NULL);
#endif
 {
  self->setBackgroundVerticalFormatting(fmt);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBackgroundVerticalFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBackgroundHorizontalFormatting of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_getBackgroundHorizontalFormatting00
static int tolua_CEGUI_CEGUI_FrameComponent_getBackgroundHorizontalFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FrameComponent* self = (const CEGUI::FrameComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBackgroundHorizontalFormatting'",NULL);
#endif
 {
  CEGUI::HorizontalFormatting tolua_ret = (CEGUI::HorizontalFormatting)  self->getBackgroundHorizontalFormatting();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBackgroundHorizontalFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBackgroundHorizontalFormatting of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setBackgroundHorizontalFormatting00
static int tolua_CEGUI_CEGUI_FrameComponent_setBackgroundHorizontalFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FrameComponent* self = (CEGUI::FrameComponent*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::HorizontalFormatting fmt = ((CEGUI::HorizontalFormatting) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBackgroundHorizontalFormatting'",NULL);
#endif
 {
  self->setBackgroundHorizontalFormatting(fmt);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBackgroundHorizontalFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImage of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_getImage00
static int tolua_CEGUI_CEGUI_FrameComponent_getImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FrameComponent* self = (const CEGUI::FrameComponent*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::FrameImageComponent part = ((CEGUI::FrameImageComponent) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImage'",NULL);
#endif
 {
  const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getImage(part);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setImage of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setImage00
static int tolua_CEGUI_CEGUI_FrameComponent_setImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FrameComponent* self = (CEGUI::FrameComponent*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::FrameImageComponent part = ((CEGUI::FrameImageComponent) (int)  tolua_tonumber(tolua_S,2,0));
  const CEGUI::Image* image = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setImage'",NULL);
#endif
 {
  self->setImage(part,image);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setImage of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setImage01
static int tolua_CEGUI_CEGUI_FrameComponent_setImage01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::FrameComponent* self = (CEGUI::FrameComponent*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::FrameImageComponent part = ((CEGUI::FrameImageComponent) (int)  tolua_tonumber(tolua_S,2,0));
  utf8string imageset = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  utf8string image = ((utf8string)  tolua_toutf8string(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setImage'",NULL);
#endif
 {
  self->setImage(part,imageset,image);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_FrameComponent_setImage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_new00
static int tolua_CEGUI_CEGUI_FrameComponent_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::FrameComponent* tolua_ret = (CEGUI::FrameComponent*)  new CEGUI::FrameComponent();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::FrameComponent");
 }
 }
 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  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_new00_local
static int tolua_CEGUI_CEGUI_FrameComponent_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::FrameComponent* tolua_ret = (CEGUI::FrameComponent*)  new CEGUI::FrameComponent();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::FrameComponent");
 }
 }
 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: getImage of class  CEGUI::ImageryComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageryComponent_getImage00
static int tolua_CEGUI_CEGUI_ImageryComponent_getImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageryComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageryComponent* self = (const CEGUI::ImageryComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImage'",NULL);
#endif
 {
  const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getImage();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setImage of class  CEGUI::ImageryComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageryComponent_setImage00
static int tolua_CEGUI_CEGUI_ImageryComponent_setImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageryComponent",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageryComponent* self = (CEGUI::ImageryComponent*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Image* image = ((const CEGUI::Image*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setImage'",NULL);
#endif
 {
  self->setImage(image);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setImage of class  CEGUI::ImageryComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageryComponent_setImage01
static int tolua_CEGUI_CEGUI_ImageryComponent_setImage01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageryComponent",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ImageryComponent* self = (CEGUI::ImageryComponent*)  tolua_tousertype(tolua_S,1,0);
  utf8string imageset = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string image = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setImage'",NULL);
#endif
 {
  self->setImage(imageset,image);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ImageryComponent_setImage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVerticalFormatting of class  CEGUI::ImageryComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageryComponent_getVerticalFormatting00
static int tolua_CEGUI_CEGUI_ImageryComponent_getVerticalFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageryComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageryComponent* self = (const CEGUI::ImageryComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVerticalFormatting'",NULL);
#endif
 {
  CEGUI::VerticalFormatting tolua_ret = (CEGUI::VerticalFormatting)  self->getVerticalFormatting();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVerticalFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVerticalFormatting of class  CEGUI::ImageryComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageryComponent_setVerticalFormatting00
static int tolua_CEGUI_CEGUI_ImageryComponent_setVerticalFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageryComponent",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageryComponent* self = (CEGUI::ImageryComponent*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::VerticalFormatting fmt = ((CEGUI::VerticalFormatting) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVerticalFormatting'",NULL);
#endif
 {
  self->setVerticalFormatting(fmt);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVerticalFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHorizontalFormatting of class  CEGUI::ImageryComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageryComponent_getHorizontalFormatting00
static int tolua_CEGUI_CEGUI_ImageryComponent_getHorizontalFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageryComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageryComponent* self = (const CEGUI::ImageryComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHorizontalFormatting'",NULL);
#endif
 {
  CEGUI::HorizontalFormatting tolua_ret = (CEGUI::HorizontalFormatting)  self->getHorizontalFormatting();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorizontalFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHorizontalFormatting of class  CEGUI::ImageryComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageryComponent_setHorizontalFormatting00
static int tolua_CEGUI_CEGUI_ImageryComponent_setHorizontalFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageryComponent",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageryComponent* self = (CEGUI::ImageryComponent*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::HorizontalFormatting fmt = ((CEGUI::HorizontalFormatting) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHorizontalFormatting'",NULL);
#endif
 {
  self->setHorizontalFormatting(fmt);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHorizontalFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getImagePropertySource of class  CEGUI::ImageryComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageryComponent_getImagePropertySource00
static int tolua_CEGUI_CEGUI_ImageryComponent_getImagePropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageryComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageryComponent* self = (const CEGUI::ImageryComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImagePropertySource'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getImagePropertySource();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImagePropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setImagePropertySource of class  CEGUI::ImageryComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageryComponent_setImagePropertySource00
static int tolua_CEGUI_CEGUI_ImageryComponent_setImagePropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageryComponent",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageryComponent* self = (CEGUI::ImageryComponent*)  tolua_tousertype(tolua_S,1,0);
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setImagePropertySource'",NULL);
#endif
 {
  self->setImagePropertySource(property);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setImagePropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::ImageryComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageryComponent_new00
static int tolua_CEGUI_CEGUI_ImageryComponent_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImageryComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::ImageryComponent* tolua_ret = (CEGUI::ImageryComponent*)  new CEGUI::ImageryComponent();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ImageryComponent");
 }
 }
 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  CEGUI::ImageryComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageryComponent_new00_local
static int tolua_CEGUI_CEGUI_ImageryComponent_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImageryComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::ImageryComponent* tolua_ret = (CEGUI::ImageryComponent*)  new CEGUI::ImageryComponent();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::ImageryComponent");
 }
 }
 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: getText of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_getText00
static int tolua_CEGUI_CEGUI_TextComponent_getText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TextComponent* self = (const CEGUI::TextComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getText'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getText();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setText of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_setText00
static int tolua_CEGUI_CEGUI_TextComponent_setText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TextComponent* self = (CEGUI::TextComponent*)  tolua_tousertype(tolua_S,1,0);
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setText'",NULL);
#endif
 {
  self->setText(text);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFont of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_getFont00
static int tolua_CEGUI_CEGUI_TextComponent_getFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TextComponent* self = (const CEGUI::TextComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFont'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getFont();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFont'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFont of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_setFont00
static int tolua_CEGUI_CEGUI_TextComponent_setFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TextComponent* self = (CEGUI::TextComponent*)  tolua_tousertype(tolua_S,1,0);
  utf8string font = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFont'",NULL);
#endif
 {
  self->setFont(font);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFont'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVerticalFormatting of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_getVerticalFormatting00
static int tolua_CEGUI_CEGUI_TextComponent_getVerticalFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TextComponent* self = (const CEGUI::TextComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVerticalFormatting'",NULL);
#endif
 {
  CEGUI::VerticalTextFormatting tolua_ret = (CEGUI::VerticalTextFormatting)  self->getVerticalFormatting();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVerticalFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVerticalFormatting of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_setVerticalFormatting00
static int tolua_CEGUI_CEGUI_TextComponent_setVerticalFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TextComponent* self = (CEGUI::TextComponent*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::VerticalTextFormatting fmt = ((CEGUI::VerticalTextFormatting) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVerticalFormatting'",NULL);
#endif
 {
  self->setVerticalFormatting(fmt);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVerticalFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHorizontalFormatting of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_getHorizontalFormatting00
static int tolua_CEGUI_CEGUI_TextComponent_getHorizontalFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TextComponent* self = (const CEGUI::TextComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHorizontalFormatting'",NULL);
#endif
 {
  CEGUI::HorizontalTextFormatting tolua_ret = (CEGUI::HorizontalTextFormatting)  self->getHorizontalFormatting();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorizontalFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHorizontalFormatting of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_setHorizontalFormatting00
static int tolua_CEGUI_CEGUI_TextComponent_setHorizontalFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TextComponent* self = (CEGUI::TextComponent*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::HorizontalTextFormatting fmt = ((CEGUI::HorizontalTextFormatting) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHorizontalFormatting'",NULL);
#endif
 {
  self->setHorizontalFormatting(fmt);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHorizontalFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getTextPropertySource of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_getTextPropertySource00
static int tolua_CEGUI_CEGUI_TextComponent_getTextPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TextComponent* self = (const CEGUI::TextComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTextPropertySource'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getTextPropertySource();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTextPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTextPropertySource of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_setTextPropertySource00
static int tolua_CEGUI_CEGUI_TextComponent_setTextPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TextComponent* self = (CEGUI::TextComponent*)  tolua_tousertype(tolua_S,1,0);
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTextPropertySource'",NULL);
#endif
 {
  self->setTextPropertySource(property);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTextPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getFontPropertySource of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_getFontPropertySource00
static int tolua_CEGUI_CEGUI_TextComponent_getFontPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TextComponent* self = (const CEGUI::TextComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFontPropertySource'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getFontPropertySource();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFontPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFontPropertySource of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_setFontPropertySource00
static int tolua_CEGUI_CEGUI_TextComponent_setFontPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TextComponent* self = (CEGUI::TextComponent*)  tolua_tousertype(tolua_S,1,0);
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFontPropertySource'",NULL);
#endif
 {
  self->setFontPropertySource(property);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFontPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_new00
static int tolua_CEGUI_CEGUI_TextComponent_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::TextComponent* tolua_ret = (CEGUI::TextComponent*)  new CEGUI::TextComponent();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TextComponent");
 }
 }
 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  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_new00_local
static int tolua_CEGUI_CEGUI_TextComponent_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::TextComponent* tolua_ret = (CEGUI::TextComponent*)  new CEGUI::TextComponent();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::TextComponent");
 }
 }
 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: render of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_render00
static int tolua_CEGUI_CEGUI_ImagerySection_render00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::Rect",1,&tolua_err) ||
 !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImagerySection* self = (const CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* srcWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::ColourRect* modColours = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Rect* clipper = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,4,0));
  bool clipToDisplay = ((bool)  tolua_toboolean(tolua_S,5,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*srcWindow,modColours,clipper,clipToDisplay);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'render'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_render01
static int tolua_CEGUI_CEGUI_ImagerySection_render01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::Rect",1,&tolua_err) ||
 !tolua_isboolean(tolua_S,6,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::ImagerySection* self = (const CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* srcWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Rect* baseRect = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::ColourRect* modColours = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Rect* clipper = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,5,0));
  bool clipToDisplay = ((bool)  tolua_toboolean(tolua_S,6,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*srcWindow,*baseRect,modColours,clipper,clipToDisplay);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ImagerySection_render00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: addImageryComponent of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_addImageryComponent00
static int tolua_CEGUI_CEGUI_ImagerySection_addImageryComponent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ImageryComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagerySection* self = (CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ImageryComponent* img = ((const CEGUI::ImageryComponent*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addImageryComponent'",NULL);
#endif
 {
  self->addImageryComponent(*img);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addImageryComponent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearImageryComponents of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_clearImageryComponents00
static int tolua_CEGUI_CEGUI_ImagerySection_clearImageryComponents00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagerySection* self = (CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearImageryComponents'",NULL);
#endif
 {
  self->clearImageryComponents();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearImageryComponents'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addTextComponent of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_addTextComponent00
static int tolua_CEGUI_CEGUI_ImagerySection_addTextComponent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::TextComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagerySection* self = (CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::TextComponent* text = ((const CEGUI::TextComponent*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addTextComponent'",NULL);
#endif
 {
  self->addTextComponent(*text);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addTextComponent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearTextComponents of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_clearTextComponents00
static int tolua_CEGUI_CEGUI_ImagerySection_clearTextComponents00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagerySection* self = (CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearTextComponents'",NULL);
#endif
 {
  self->clearTextComponents();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearTextComponents'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearFrameComponents of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_clearFrameComponents00
static int tolua_CEGUI_CEGUI_ImagerySection_clearFrameComponents00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagerySection* self = (CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearFrameComponents'",NULL);
#endif
 {
  self->clearFrameComponents();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearFrameComponents'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addFrameComponent of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_addFrameComponent00
static int tolua_CEGUI_CEGUI_ImagerySection_addFrameComponent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagerySection* self = (CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::FrameComponent* frame = ((const CEGUI::FrameComponent*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addFrameComponent'",NULL);
#endif
 {
  self->addFrameComponent(*frame);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addFrameComponent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMasterColours of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_getMasterColours00
static int tolua_CEGUI_CEGUI_ImagerySection_getMasterColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImagerySection* self = (const CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMasterColours'",NULL);
#endif
 {
  const CEGUI::ColourRect& tolua_ret = (const CEGUI::ColourRect&)  self->getMasterColours();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::ColourRect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMasterColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMasterColours of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_setMasterColours00
static int tolua_CEGUI_CEGUI_ImagerySection_setMasterColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagerySection* self = (CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ColourRect* cols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMasterColours'",NULL);
#endif
 {
  self->setMasterColours(*cols);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMasterColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getName of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_getName00
static int tolua_CEGUI_CEGUI_ImagerySection_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImagerySection* self = (const CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMasterColoursPropertySource of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_setMasterColoursPropertySource00
static int tolua_CEGUI_CEGUI_ImagerySection_setMasterColoursPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagerySection* self = (CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMasterColoursPropertySource'",NULL);
#endif
 {
  self->setMasterColoursPropertySource(property);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMasterColoursPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMasterColoursPropertyIsColourRect of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_setMasterColoursPropertyIsColourRect00
static int tolua_CEGUI_CEGUI_ImagerySection_setMasterColoursPropertyIsColourRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagerySection* self = (CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMasterColoursPropertyIsColourRect'",NULL);
#endif
 {
  self->setMasterColoursPropertyIsColourRect(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMasterColoursPropertyIsColourRect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBoundingRect of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_getBoundingRect00
static int tolua_CEGUI_CEGUI_ImagerySection_getBoundingRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImagerySection* self = (const CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* wnd = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBoundingRect'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getBoundingRect(*wnd);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBoundingRect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBoundingRect of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_getBoundingRect01
static int tolua_CEGUI_CEGUI_ImagerySection_getBoundingRect01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::ImagerySection* self = (const CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* wnd = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Rect* rect = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBoundingRect'",NULL);
#endif
 {
  CEGUI::Rect tolua_ret = (CEGUI::Rect)  self->getBoundingRect(*wnd,*rect);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ImagerySection_getBoundingRect00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_new00
static int tolua_CEGUI_CEGUI_ImagerySection_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::ImagerySection* tolua_ret = (CEGUI::ImagerySection*)  new CEGUI::ImagerySection();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ImagerySection");
 }
 }
 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  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_new00_local
static int tolua_CEGUI_CEGUI_ImagerySection_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::ImagerySection* tolua_ret = (CEGUI::ImagerySection*)  new CEGUI::ImagerySection();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::ImagerySection");
 }
 }
 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 of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_new01
static int tolua_CEGUI_CEGUI_ImagerySection_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::ImagerySection* tolua_ret = (CEGUI::ImagerySection*)  new CEGUI::ImagerySection(name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ImagerySection");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ImagerySection_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::ImagerySection */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagerySection_new01_local
static int tolua_CEGUI_CEGUI_ImagerySection_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::ImagerySection* tolua_ret = (CEGUI::ImagerySection*)  new CEGUI::ImagerySection(name);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::ImagerySection");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_ImagerySection_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_render00
static int tolua_CEGUI_CEGUI_SectionSpecification_render00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::Rect",1,&tolua_err) ||
 !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SectionSpecification* self = (const CEGUI::SectionSpecification*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* srcWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::ColourRect* modcols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Rect* clipper = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,4,0));
  bool clipToDisplay = ((bool)  tolua_toboolean(tolua_S,5,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*srcWindow,modcols,clipper,clipToDisplay);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'render'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_render01
static int tolua_CEGUI_CEGUI_SectionSpecification_render01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::Rect",1,&tolua_err) ||
 !tolua_isboolean(tolua_S,6,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::SectionSpecification* self = (const CEGUI::SectionSpecification*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* srcWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Rect* baseRect = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::ColourRect* modcols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Rect* clipper = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,5,0));
  bool clipToDisplay = ((bool)  tolua_toboolean(tolua_S,6,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*srcWindow,*baseRect,modcols,clipper,clipToDisplay);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SectionSpecification_render00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOwnerWidgetLookFeel of class  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_getOwnerWidgetLookFeel00
static int tolua_CEGUI_CEGUI_SectionSpecification_getOwnerWidgetLookFeel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SectionSpecification* self = (const CEGUI::SectionSpecification*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOwnerWidgetLookFeel'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getOwnerWidgetLookFeel();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOwnerWidgetLookFeel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSectionName of class  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_getSectionName00
static int tolua_CEGUI_CEGUI_SectionSpecification_getSectionName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SectionSpecification* self = (const CEGUI::SectionSpecification*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSectionName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getSectionName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSectionName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOverrideColours of class  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_getOverrideColours00
static int tolua_CEGUI_CEGUI_SectionSpecification_getOverrideColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SectionSpecification* self = (const CEGUI::SectionSpecification*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOverrideColours'",NULL);
#endif
 {
  const CEGUI::ColourRect& tolua_ret = (const CEGUI::ColourRect&)  self->getOverrideColours();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::ColourRect");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getOverrideColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setOverrideColours of class  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_setOverrideColours00
static int tolua_CEGUI_CEGUI_SectionSpecification_setOverrideColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SectionSpecification* self = (CEGUI::SectionSpecification*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ColourRect* cols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOverrideColours'",NULL);
#endif
 {
  self->setOverrideColours(*cols);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setOverrideColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setUsingOverrideColours of class  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_setUsingOverrideColours00
static int tolua_CEGUI_CEGUI_SectionSpecification_setUsingOverrideColours00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SectionSpecification* self = (CEGUI::SectionSpecification*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUsingOverrideColours'",NULL);
#endif
 {
  self->setUsingOverrideColours(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUsingOverrideColours'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setOverrideColoursPropertySource of class  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_setOverrideColoursPropertySource00
static int tolua_CEGUI_CEGUI_SectionSpecification_setOverrideColoursPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SectionSpecification* self = (CEGUI::SectionSpecification*)  tolua_tousertype(tolua_S,1,0);
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOverrideColoursPropertySource'",NULL);
#endif
 {
  self->setOverrideColoursPropertySource(property);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setOverrideColoursPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setOverrideColoursPropertyIsColourRect of class  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_setOverrideColoursPropertyIsColourRect00
static int tolua_CEGUI_CEGUI_SectionSpecification_setOverrideColoursPropertyIsColourRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SectionSpecification* self = (CEGUI::SectionSpecification*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOverrideColoursPropertyIsColourRect'",NULL);
#endif
 {
  self->setOverrideColoursPropertyIsColourRect(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setOverrideColoursPropertyIsColourRect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRenderControlPropertySource of class  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_setRenderControlPropertySource00
static int tolua_CEGUI_CEGUI_SectionSpecification_setRenderControlPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SectionSpecification* self = (CEGUI::SectionSpecification*)  tolua_tousertype(tolua_S,1,0);
  utf8string property = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRenderControlPropertySource'",NULL);
#endif
 {
  self->setRenderControlPropertySource(property);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRenderControlPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_new00
static int tolua_CEGUI_CEGUI_SectionSpecification_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
 !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
 !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string owner = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string sectionName = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  const string controlPropertySource = ((const string)  tolua_tocppstring(tolua_S,4,0));
  const string controlPropertyValue = ((const string)  tolua_tocppstring(tolua_S,5,0));
  const string controlPropertyWidget = ((const string)  tolua_tocppstring(tolua_S,6,0));
 {
  CEGUI::SectionSpecification* tolua_ret = (CEGUI::SectionSpecification*)  new CEGUI::SectionSpecification(owner,sectionName,controlPropertySource,controlPropertyValue,controlPropertyWidget);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::SectionSpecification");
 }
 }
 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  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_new00_local
static int tolua_CEGUI_CEGUI_SectionSpecification_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
 !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
 !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string owner = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string sectionName = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  const string controlPropertySource = ((const string)  tolua_tocppstring(tolua_S,4,0));
  const string controlPropertyValue = ((const string)  tolua_tocppstring(tolua_S,5,0));
  const string controlPropertyWidget = ((const string)  tolua_tocppstring(tolua_S,6,0));
 {
  CEGUI::SectionSpecification* tolua_ret = (CEGUI::SectionSpecification*)  new CEGUI::SectionSpecification(owner,sectionName,controlPropertySource,controlPropertyValue,controlPropertyWidget);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::SectionSpecification");
 }
 }
 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 of class  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_new01
static int tolua_CEGUI_CEGUI_SectionSpecification_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,0,&tolua_err) ||
 !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
 !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,7,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  utf8string owner = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string sectionName = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  utf8string controlPropertySource = ((utf8string)  tolua_toutf8string(tolua_S,4,0));
  const string controlPropertyValue = ((const string)  tolua_tocppstring(tolua_S,5,0));
  const string controlPropertyWidget = ((const string)  tolua_tocppstring(tolua_S,6,0));
  const CEGUI::ColourRect* cols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,7,0));
 {
  CEGUI::SectionSpecification* tolua_ret = (CEGUI::SectionSpecification*)  new CEGUI::SectionSpecification(owner,sectionName,controlPropertySource,controlPropertyValue,controlPropertyWidget,*cols);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::SectionSpecification");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SectionSpecification_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::SectionSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SectionSpecification_new01_local
static int tolua_CEGUI_CEGUI_SectionSpecification_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,0,&tolua_err) ||
 !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
 !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,7,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  utf8string owner = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string sectionName = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  utf8string controlPropertySource = ((utf8string)  tolua_toutf8string(tolua_S,4,0));
  const string controlPropertyValue = ((const string)  tolua_tocppstring(tolua_S,5,0));
  const string controlPropertyWidget = ((const string)  tolua_tocppstring(tolua_S,6,0));
  const CEGUI::ColourRect* cols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,7,0));
 {
  CEGUI::SectionSpecification* tolua_ret = (CEGUI::SectionSpecification*)  new CEGUI::SectionSpecification(owner,sectionName,controlPropertySource,controlPropertyValue,controlPropertyWidget,*cols);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::SectionSpecification");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SectionSpecification_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  CEGUI::LayerSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_LayerSpecification_render00
static int tolua_CEGUI_CEGUI_LayerSpecification_render00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::LayerSpecification",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::Rect",1,&tolua_err) ||
 !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::LayerSpecification* self = (const CEGUI::LayerSpecification*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* srcWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::ColourRect* modcols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Rect* clipper = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,4,0));
  bool clipToDisplay = ((bool)  tolua_toboolean(tolua_S,5,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*srcWindow,modcols,clipper,clipToDisplay);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'render'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  CEGUI::LayerSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_LayerSpecification_render01
static int tolua_CEGUI_CEGUI_LayerSpecification_render01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::LayerSpecification",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::Rect",1,&tolua_err) ||
 !tolua_isboolean(tolua_S,6,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::LayerSpecification* self = (const CEGUI::LayerSpecification*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* srcWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Rect* baseRect = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::ColourRect* modcols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Rect* clipper = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,5,0));
  bool clipToDisplay = ((bool)  tolua_toboolean(tolua_S,6,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*srcWindow,*baseRect,modcols,clipper,clipToDisplay);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_LayerSpecification_render00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: addSectionSpecification of class  CEGUI::LayerSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_LayerSpecification_addSectionSpecification00
static int tolua_CEGUI_CEGUI_LayerSpecification_addSectionSpecification00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::LayerSpecification",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::SectionSpecification",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::LayerSpecification* self = (CEGUI::LayerSpecification*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::SectionSpecification* section = ((const CEGUI::SectionSpecification*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addSectionSpecification'",NULL);
#endif
 {
  self->addSectionSpecification(*section);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addSectionSpecification'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearSectionSpecifications of class  CEGUI::LayerSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_LayerSpecification_clearSectionSpecifications00
static int tolua_CEGUI_CEGUI_LayerSpecification_clearSectionSpecifications00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::LayerSpecification",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::LayerSpecification* self = (CEGUI::LayerSpecification*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearSectionSpecifications'",NULL);
#endif
 {
  self->clearSectionSpecifications();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearSectionSpecifications'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLayerPriority of class  CEGUI::LayerSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_LayerSpecification_getLayerPriority00
static int tolua_CEGUI_CEGUI_LayerSpecification_getLayerPriority00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::LayerSpecification",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::LayerSpecification* self = (const CEGUI::LayerSpecification*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLayerPriority'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getLayerPriority();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLayerPriority'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator< of class  CEGUI::LayerSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_LayerSpecification__lt00
static int tolua_CEGUI_CEGUI_LayerSpecification__lt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::LayerSpecification",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::LayerSpecification",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::LayerSpecification* self = (const CEGUI::LayerSpecification*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::LayerSpecification* other = ((const CEGUI::LayerSpecification*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator<'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->operator<(*other);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.lt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::LayerSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_LayerSpecification_new00
static int tolua_CEGUI_CEGUI_LayerSpecification_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::LayerSpecification",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  unsigned int priority = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
 {
  CEGUI::LayerSpecification* tolua_ret = (CEGUI::LayerSpecification*)  new CEGUI::LayerSpecification(priority);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::LayerSpecification");
 }
 }
 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  CEGUI::LayerSpecification */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_LayerSpecification_new00_local
static int tolua_CEGUI_CEGUI_LayerSpecification_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::LayerSpecification",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  unsigned int priority = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
 {
  CEGUI::LayerSpecification* tolua_ret = (CEGUI::LayerSpecification*)  new CEGUI::LayerSpecification(priority);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::LayerSpecification");
 }
 }
 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: render of class  CEGUI::StateImagery */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_StateImagery_render00
static int tolua_CEGUI_CEGUI_StateImagery_render00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::StateImagery",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::Rect",1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::StateImagery* self = (const CEGUI::StateImagery*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* srcWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::ColourRect* modcols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Rect* clipper = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*srcWindow,modcols,clipper);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'render'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  CEGUI::StateImagery */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_StateImagery_render01
static int tolua_CEGUI_CEGUI_StateImagery_render01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::StateImagery",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Rect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::Rect",1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::StateImagery* self = (const CEGUI::StateImagery*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* srcWindow = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Rect* baseRect = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::ColourRect* modcols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Rect* clipper = ((const CEGUI::Rect*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*srcWindow,*baseRect,modcols,clipper);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_StateImagery_render00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: addLayer of class  CEGUI::StateImagery */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_StateImagery_addLayer00
static int tolua_CEGUI_CEGUI_StateImagery_addLayer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::StateImagery",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::LayerSpecification",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::StateImagery* self = (CEGUI::StateImagery*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::LayerSpecification* layer = ((const CEGUI::LayerSpecification*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addLayer'",NULL);
#endif
 {
  self->addLayer(*layer);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addLayer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearLayers of class  CEGUI::StateImagery */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_StateImagery_clearLayers00
static int tolua_CEGUI_CEGUI_StateImagery_clearLayers00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::StateImagery",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::StateImagery* self = (CEGUI::StateImagery*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearLayers'",NULL);
#endif
 {
  self->clearLayers();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearLayers'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getName of class  CEGUI::StateImagery */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_StateImagery_getName00
static int tolua_CEGUI_CEGUI_StateImagery_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::StateImagery",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::StateImagery* self = (const CEGUI::StateImagery*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setClippedToDisplay of class  CEGUI::StateImagery */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_StateImagery_setClippedToDisplay00
static int tolua_CEGUI_CEGUI_StateImagery_setClippedToDisplay00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::StateImagery",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::StateImagery* self = (CEGUI::StateImagery*)  tolua_tousertype(tolua_S,1,0);
  bool setting = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setClippedToDisplay'",NULL);
#endif
 {
  self->setClippedToDisplay(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setClippedToDisplay'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::StateImagery */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_StateImagery_new00
static int tolua_CEGUI_CEGUI_StateImagery_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::StateImagery",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::StateImagery* tolua_ret = (CEGUI::StateImagery*)  new CEGUI::StateImagery(name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::StateImagery");
 }
 }
 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  CEGUI::StateImagery */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_StateImagery_new00_local
static int tolua_CEGUI_CEGUI_StateImagery_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::StateImagery",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::StateImagery* tolua_ret = (CEGUI::StateImagery*)  new CEGUI::StateImagery(name);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::StateImagery");
 }
 }
 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 of class  CEGUI::StateImagery */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_StateImagery_new01
static int tolua_CEGUI_CEGUI_StateImagery_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::StateImagery",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
 {
  CEGUI::StateImagery* tolua_ret = (CEGUI::StateImagery*)  new CEGUI::StateImagery();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::StateImagery");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_StateImagery_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::StateImagery */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_StateImagery_new01_local
static int tolua_CEGUI_CEGUI_StateImagery_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::StateImagery",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
 {
  CEGUI::StateImagery* tolua_ret = (CEGUI::StateImagery*)  new CEGUI::StateImagery();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::StateImagery");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_StateImagery_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_create00
static int tolua_CEGUI_CEGUI_WidgetComponent_create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetComponent* self = (const CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* parent = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create'",NULL);
#endif
 {
  self->create(*parent);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getComponentArea of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_getComponentArea00
static int tolua_CEGUI_CEGUI_WidgetComponent_getComponentArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetComponent* self = (const CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getComponentArea'",NULL);
#endif
 {
  const CEGUI::ComponentArea& tolua_ret = (const CEGUI::ComponentArea&)  self->getComponentArea();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::ComponentArea");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getComponentArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setComponentArea of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_setComponentArea00
static int tolua_CEGUI_CEGUI_WidgetComponent_setComponentArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ComponentArea",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetComponent* self = (CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ComponentArea* area = ((const CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setComponentArea'",NULL);
#endif
 {
  self->setComponentArea(*area);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setComponentArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBaseWidgetType of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_getBaseWidgetType00
static int tolua_CEGUI_CEGUI_WidgetComponent_getBaseWidgetType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetComponent* self = (const CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBaseWidgetType'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getBaseWidgetType();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBaseWidgetType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBaseWidgetType of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_setBaseWidgetType00
static int tolua_CEGUI_CEGUI_WidgetComponent_setBaseWidgetType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetComponent* self = (CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
  utf8string type = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBaseWidgetType'",NULL);
#endif
 {
  self->setBaseWidgetType(type);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBaseWidgetType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWidgetLookName of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_getWidgetLookName00
static int tolua_CEGUI_CEGUI_WidgetComponent_getWidgetLookName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetComponent* self = (const CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWidgetLookName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getWidgetLookName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWidgetLookName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setWidgetLookName of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_setWidgetLookName00
static int tolua_CEGUI_CEGUI_WidgetComponent_setWidgetLookName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetComponent* self = (CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
  utf8string look = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWidgetLookName'",NULL);
#endif
 {
  self->setWidgetLookName(look);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWidgetLookName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWidgetNameSuffix of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_getWidgetNameSuffix00
static int tolua_CEGUI_CEGUI_WidgetComponent_getWidgetNameSuffix00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetComponent* self = (const CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWidgetNameSuffix'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getWidgetNameSuffix();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWidgetNameSuffix'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setWidgetNameSuffix of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_setWidgetNameSuffix00
static int tolua_CEGUI_CEGUI_WidgetComponent_setWidgetNameSuffix00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetComponent* self = (CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
  utf8string suffix = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWidgetNameSuffix'",NULL);
#endif
 {
  self->setWidgetNameSuffix(suffix);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWidgetNameSuffix'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWindowRendererType of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_getWindowRendererType00
static int tolua_CEGUI_CEGUI_WidgetComponent_getWindowRendererType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetComponent* self = (const CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWindowRendererType'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getWindowRendererType();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWindowRendererType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setWindowRendererType of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_setWindowRendererType00
static int tolua_CEGUI_CEGUI_WidgetComponent_setWindowRendererType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetComponent* self = (CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
  utf8string type = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWindowRendererType'",NULL);
#endif
 {
  self->setWindowRendererType(type);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWindowRendererType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVerticalWidgetAlignment of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_getVerticalWidgetAlignment00
static int tolua_CEGUI_CEGUI_WidgetComponent_getVerticalWidgetAlignment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetComponent* self = (const CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getVerticalWidgetAlignment'",NULL);
#endif
 {
  CEGUI::VerticalAlignment tolua_ret = (CEGUI::VerticalAlignment)  self->getVerticalWidgetAlignment();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVerticalWidgetAlignment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVerticalWidgetAlignment of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_setVerticalWidgetAlignment00
static int tolua_CEGUI_CEGUI_WidgetComponent_setVerticalWidgetAlignment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetComponent* self = (CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::VerticalAlignment alignment = ((CEGUI::VerticalAlignment) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVerticalWidgetAlignment'",NULL);
#endif
 {
  self->setVerticalWidgetAlignment(alignment);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVerticalWidgetAlignment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHorizontalWidgetAlignment of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_getHorizontalWidgetAlignment00
static int tolua_CEGUI_CEGUI_WidgetComponent_getHorizontalWidgetAlignment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetComponent* self = (const CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHorizontalWidgetAlignment'",NULL);
#endif
 {
  CEGUI::HorizontalAlignment tolua_ret = (CEGUI::HorizontalAlignment)  self->getHorizontalWidgetAlignment();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorizontalWidgetAlignment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setHorizontalWidgetAlignment of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_setHorizontalWidgetAlignment00
static int tolua_CEGUI_CEGUI_WidgetComponent_setHorizontalWidgetAlignment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetComponent* self = (CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::HorizontalAlignment alignment = ((CEGUI::HorizontalAlignment) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHorizontalWidgetAlignment'",NULL);
#endif
 {
  self->setHorizontalWidgetAlignment(alignment);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHorizontalWidgetAlignment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addPropertyInitialiser of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_addPropertyInitialiser00
static int tolua_CEGUI_CEGUI_WidgetComponent_addPropertyInitialiser00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::PropertyInitialiser",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetComponent* self = (CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::PropertyInitialiser* initialiser = ((const CEGUI::PropertyInitialiser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addPropertyInitialiser'",NULL);
#endif
 {
  self->addPropertyInitialiser(*initialiser);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addPropertyInitialiser'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearPropertyInitialisers of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_clearPropertyInitialisers00
static int tolua_CEGUI_CEGUI_WidgetComponent_clearPropertyInitialisers00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetComponent* self = (CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearPropertyInitialisers'",NULL);
#endif
 {
  self->clearPropertyInitialisers();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearPropertyInitialisers'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: layout of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_layout00
static int tolua_CEGUI_CEGUI_WidgetComponent_layout00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetComponent* self = (const CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* owner = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'layout'",NULL);
#endif
 {
  self->layout(*owner);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'layout'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findPropertyInitialiser of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_findPropertyInitialiser00
static int tolua_CEGUI_CEGUI_WidgetComponent_findPropertyInitialiser00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetComponent* self = (const CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,1,0);
  utf8string propertyName = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findPropertyInitialiser'",NULL);
#endif
 {
  const CEGUI::PropertyInitialiser* tolua_ret = (const CEGUI::PropertyInitialiser*)  self->findPropertyInitialiser(propertyName);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::PropertyInitialiser");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findPropertyInitialiser'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_new00
static int tolua_CEGUI_CEGUI_WidgetComponent_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::WidgetComponent* tolua_ret = (CEGUI::WidgetComponent*)  new CEGUI::WidgetComponent();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::WidgetComponent");
 }
 }
 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  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_new00_local
static int tolua_CEGUI_CEGUI_WidgetComponent_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::WidgetComponent* tolua_ret = (CEGUI::WidgetComponent*)  new CEGUI::WidgetComponent();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::WidgetComponent");
 }
 }
 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 of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_new01
static int tolua_CEGUI_CEGUI_WidgetComponent_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  utf8string type = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string look = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  utf8string suffix = ((utf8string)  tolua_toutf8string(tolua_S,4,0));
  utf8string renderer = ((utf8string)  tolua_toutf8string(tolua_S,5,0));
 {
  CEGUI::WidgetComponent* tolua_ret = (CEGUI::WidgetComponent*)  new CEGUI::WidgetComponent(type,look,suffix,renderer);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::WidgetComponent");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_WidgetComponent_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_new01_local
static int tolua_CEGUI_CEGUI_WidgetComponent_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,4,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,5,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  utf8string type = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string look = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
  utf8string suffix = ((utf8string)  tolua_toutf8string(tolua_S,4,0));
  utf8string renderer = ((utf8string)  tolua_toutf8string(tolua_S,5,0));
 {
  CEGUI::WidgetComponent* tolua_ret = (CEGUI::WidgetComponent*)  new CEGUI::WidgetComponent(type,look,suffix,renderer);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::WidgetComponent");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_WidgetComponent_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getStateImagery of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_getStateImagery00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_getStateImagery00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookFeel* self = (const CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  utf8string state = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getStateImagery'",NULL);
#endif
 {
  CEGUI::StateImagery& tolua_ret = (CEGUI::StateImagery&)  self->getStateImagery(state);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::StateImagery");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getStateImagery'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getImagerySection of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_getImagerySection00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_getImagerySection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookFeel* self = (const CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  utf8string section = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getImagerySection'",NULL);
#endif
 {
  CEGUI::ImagerySection& tolua_ret = (CEGUI::ImagerySection&)  self->getImagerySection(section);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::ImagerySection");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getImagerySection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getName of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_getName00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookFeel* self = (const CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addImagerySection of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_addImagerySection00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_addImagerySection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::ImagerySection",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::ImagerySection* section = ((const CEGUI::ImagerySection*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addImagerySection'",NULL);
#endif
 {
  self->addImagerySection(*section);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addImagerySection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addWidgetComponent of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_addWidgetComponent00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_addWidgetComponent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::WidgetComponent* widget = ((const CEGUI::WidgetComponent*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addWidgetComponent'",NULL);
#endif
 {
  self->addWidgetComponent(*widget);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addWidgetComponent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addStateSpecification of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_addStateSpecification00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_addStateSpecification00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::StateImagery",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::StateImagery* state = ((const CEGUI::StateImagery*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addStateSpecification'",NULL);
#endif
 {
  self->addStateSpecification(*state);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addStateSpecification'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addPropertyInitialiser of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_addPropertyInitialiser00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_addPropertyInitialiser00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::PropertyInitialiser",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::PropertyInitialiser* initialiser = ((const CEGUI::PropertyInitialiser*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addPropertyInitialiser'",NULL);
#endif
 {
  self->addPropertyInitialiser(*initialiser);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addPropertyInitialiser'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearImagerySections of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_clearImagerySections00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_clearImagerySections00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearImagerySections'",NULL);
#endif
 {
  self->clearImagerySections();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearImagerySections'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearWidgetComponents of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_clearWidgetComponents00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_clearWidgetComponents00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearWidgetComponents'",NULL);
#endif
 {
  self->clearWidgetComponents();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearWidgetComponents'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearStateSpecifications of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_clearStateSpecifications00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_clearStateSpecifications00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearStateSpecifications'",NULL);
#endif
 {
  self->clearStateSpecifications();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearStateSpecifications'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearPropertyInitialisers of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_clearPropertyInitialisers00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_clearPropertyInitialisers00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearPropertyInitialisers'",NULL);
#endif
 {
  self->clearPropertyInitialisers();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearPropertyInitialisers'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initialiseWidget of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_initialiseWidget00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_initialiseWidget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookFeel* self = (const CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* widget = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initialiseWidget'",NULL);
#endif
 {
  self->initialiseWidget(*widget);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initialiseWidget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isStateImageryPresent of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_isStateImageryPresent00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_isStateImageryPresent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookFeel* self = (const CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  utf8string state = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isStateImageryPresent'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isStateImageryPresent(state);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isStateImageryPresent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addNamedArea of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_addNamedArea00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_addNamedArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::NamedArea",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::NamedArea* area = ((const CEGUI::NamedArea*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addNamedArea'",NULL);
#endif
 {
  self->addNamedArea(*area);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addNamedArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearNamedAreas of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_clearNamedAreas00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_clearNamedAreas00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearNamedAreas'",NULL);
#endif
 {
  self->clearNamedAreas();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearNamedAreas'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNamedArea of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_getNamedArea00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_getNamedArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookFeel* self = (const CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNamedArea'",NULL);
#endif
 {
  const CEGUI::NamedArea& tolua_ret = (const CEGUI::NamedArea&)  self->getNamedArea(name);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::NamedArea");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getNamedArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isNamedAreaDefined of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_isNamedAreaDefined00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_isNamedAreaDefined00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookFeel* self = (const CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isNamedAreaDefined'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isNamedAreaDefined(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isNamedAreaDefined'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: layoutChildWidgets of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_layoutChildWidgets00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_layoutChildWidgets00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookFeel* self = (const CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* owner = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'layoutChildWidgets'",NULL);
#endif
 {
  self->layoutChildWidgets(*owner);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'layoutChildWidgets'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addPropertyDefinition of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_addPropertyDefinition00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_addPropertyDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::PropertyDefinition",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::PropertyDefinition* propdef = ((const CEGUI::PropertyDefinition*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addPropertyDefinition'",NULL);
#endif
 {
  self->addPropertyDefinition(*propdef);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addPropertyDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addPropertyLinkDefinition of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_addPropertyLinkDefinition00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_addPropertyLinkDefinition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::PropertyLinkDefinition",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::PropertyLinkDefinition* propdef = ((const CEGUI::PropertyLinkDefinition*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addPropertyLinkDefinition'",NULL);
#endif
 {
  self->addPropertyLinkDefinition(*propdef);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addPropertyLinkDefinition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearPropertyDefinitions of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_clearPropertyDefinitions00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_clearPropertyDefinitions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearPropertyDefinitions'",NULL);
#endif
 {
  self->clearPropertyDefinitions();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearPropertyDefinitions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clearPropertyLinkDefinitions of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_clearPropertyLinkDefinitions00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_clearPropertyLinkDefinitions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookFeel* self = (CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clearPropertyLinkDefinitions'",NULL);
#endif
 {
  self->clearPropertyLinkDefinitions();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clearPropertyLinkDefinitions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: renameChildren of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_renameChildren00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_renameChildren00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookFeel* self = (const CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Window* widget = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  utf8string newBaseName = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'renameChildren'",NULL);
#endif
 {
  self->renameChildren(*widget,newBaseName);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'renameChildren'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findPropertyInitialiser of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_findPropertyInitialiser00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_findPropertyInitialiser00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookFeel* self = (const CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  utf8string propertyName = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findPropertyInitialiser'",NULL);
#endif
 {
  const CEGUI::PropertyInitialiser* tolua_ret = (const CEGUI::PropertyInitialiser*)  self->findPropertyInitialiser(propertyName);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::PropertyInitialiser");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findPropertyInitialiser'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findWidgetComponent of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_findWidgetComponent00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_findWidgetComponent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookFeel* self = (const CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,1,0);
  utf8string nameSuffix = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findWidgetComponent'",NULL);
#endif
 {
  const CEGUI::WidgetComponent* tolua_ret = (const CEGUI::WidgetComponent*)  self->findWidgetComponent(nameSuffix);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::WidgetComponent");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findWidgetComponent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_new00
static int tolua_CEGUI_CEGUI_WidgetLookFeel_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::WidgetLookFeel* tolua_ret = (CEGUI::WidgetLookFeel*)  new CEGUI::WidgetLookFeel(name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::WidgetLookFeel");
 }
 }
 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  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_new00_local
static int tolua_CEGUI_CEGUI_WidgetLookFeel_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::WidgetLookFeel* tolua_ret = (CEGUI::WidgetLookFeel*)  new CEGUI::WidgetLookFeel(name);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::WidgetLookFeel");
 }
 }
 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 of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_new01
static int tolua_CEGUI_CEGUI_WidgetLookFeel_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
 {
  CEGUI::WidgetLookFeel* tolua_ret = (CEGUI::WidgetLookFeel*)  new CEGUI::WidgetLookFeel();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::WidgetLookFeel");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_WidgetLookFeel_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::WidgetLookFeel */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookFeel_new01_local
static int tolua_CEGUI_CEGUI_WidgetLookFeel_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
 {
  CEGUI::WidgetLookFeel* tolua_ret = (CEGUI::WidgetLookFeel*)  new CEGUI::WidgetLookFeel();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::WidgetLookFeel");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_WidgetLookFeel_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_getSingleton00
static int tolua_CEGUI_CEGUI_WidgetLookManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetLookManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::WidgetLookManager& tolua_ret = (CEGUI::WidgetLookManager&)  CEGUI::WidgetLookManager::getSingleton();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::WidgetLookManager");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: parseLookNFeelSpecification of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_parseLookNFeelSpecification00
static int tolua_CEGUI_CEGUI_WidgetLookManager_parseLookNFeelSpecification00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookManager* self = (CEGUI::WidgetLookManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string filename = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string resourceGroup = ((utf8string)  tolua_toutf8string(tolua_S,3,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'parseLookNFeelSpecification'",NULL);
#endif
 {
  self->parseLookNFeelSpecification(filename,resourceGroup);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'parseLookNFeelSpecification'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isWidgetLookAvailable of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_isWidgetLookAvailable00
static int tolua_CEGUI_CEGUI_WidgetLookManager_isWidgetLookAvailable00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookManager* self = (const CEGUI::WidgetLookManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string widget = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isWidgetLookAvailable'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isWidgetLookAvailable(widget);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isWidgetLookAvailable'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWidgetLook of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_getWidgetLook00
static int tolua_CEGUI_CEGUI_WidgetLookManager_getWidgetLook00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookManager* self = (const CEGUI::WidgetLookManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string widget = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWidgetLook'",NULL);
#endif
 {
  const CEGUI::WidgetLookFeel& tolua_ret = (const CEGUI::WidgetLookFeel&)  self->getWidgetLook(widget);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::WidgetLookFeel");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWidgetLook'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: eraseWidgetLook of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_eraseWidgetLook00
static int tolua_CEGUI_CEGUI_WidgetLookManager_eraseWidgetLook00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookManager* self = (CEGUI::WidgetLookManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string widget = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'eraseWidgetLook'",NULL);
#endif
 {
  self->eraseWidgetLook(widget);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'eraseWidgetLook'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addWidgetLook of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_addWidgetLook00
static int tolua_CEGUI_CEGUI_WidgetLookManager_addWidgetLook00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::WidgetLookFeel",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookManager* self = (CEGUI::WidgetLookManager*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::WidgetLookFeel* look = ((CEGUI::WidgetLookFeel*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addWidgetLook'",NULL);
#endif
 {
  self->addWidgetLook(*look);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addWidgetLook'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeWidgetLookToStream of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_writeWidgetLookToStream00
static int tolua_CEGUI_CEGUI_WidgetLookManager_writeWidgetLookToStream00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::OutStream",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookManager* self = (const CEGUI::WidgetLookManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::OutStream* out_stream = ((CEGUI::OutStream*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeWidgetLookToStream'",NULL);
#endif
 {
  self->writeWidgetLookToStream(name,*out_stream);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeWidgetLookToStream'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeWidgetLookSeriesToStream of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_writeWidgetLookSeriesToStream00
static int tolua_CEGUI_CEGUI_WidgetLookManager_writeWidgetLookSeriesToStream00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetLookManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::OutStream",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetLookManager* self = (const CEGUI::WidgetLookManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string prefix = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::OutStream* out_stream = ((CEGUI::OutStream*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeWidgetLookSeriesToStream'",NULL);
#endif
 {
  self->writeWidgetLookSeriesToStream(prefix,*out_stream);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeWidgetLookSeriesToStream'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_new00
static int tolua_CEGUI_CEGUI_WidgetLookManager_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetLookManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::WidgetLookManager* tolua_ret = (CEGUI::WidgetLookManager*)  new CEGUI::WidgetLookManager();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::WidgetLookManager");
 }
 }
 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  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_new00_local
static int tolua_CEGUI_CEGUI_WidgetLookManager_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetLookManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::WidgetLookManager* tolua_ret = (CEGUI::WidgetLookManager*)  new CEGUI::WidgetLookManager();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::WidgetLookManager");
 }
 }
 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: setDefaultResourceGroup of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_setDefaultResourceGroup00
static int tolua_CEGUI_CEGUI_WidgetLookManager_setDefaultResourceGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetLookManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string resourceGroup = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
 {
  CEGUI::WidgetLookManager::setDefaultResourceGroup(resourceGroup);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDefaultResourceGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultResourceGroup of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_getDefaultResourceGroup00
static int tolua_CEGUI_CEGUI_WidgetLookManager_getDefaultResourceGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::WidgetLookManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  string tolua_ret = (string)  CEGUI::WidgetLookManager::getDefaultResourceGroup();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultResourceGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: CEGUI::ceguiLua_createListboxTextItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_createListboxTextItem00
static int tolua_CEGUI_CEGUI_createListboxTextItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isutf8string(tolua_S,1,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
 !tolua_isuserdata(tolua_S,3,1,&tolua_err) ||
 !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
 !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,1,0));
  unsigned int item_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  void* item_data = ((void*)  tolua_touserdata(tolua_S,3,0));
  bool disabled = ((bool)  tolua_toboolean(tolua_S,4,false));
  bool auto_delete = ((bool)  tolua_toboolean(tolua_S,5,true));
 {
  CEGUI::ListboxTextItem* tolua_ret = (CEGUI::ListboxTextItem*)  CEGUI::ceguiLua_createListboxTextItem(text,item_id,item_data,disabled,auto_delete);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ListboxTextItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createListboxTextItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: CEGUI::ceguiLua_createTreeItem */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_createTreeItem00
static int tolua_CEGUI_CEGUI_createTreeItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isutf8string(tolua_S,1,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
 !tolua_isuserdata(tolua_S,3,1,&tolua_err) ||
 !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
 !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string text = ((utf8string)  tolua_toutf8string(tolua_S,1,0));
  unsigned int item_id = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  void* item_data = ((void*)  tolua_touserdata(tolua_S,3,0));
  bool disabled = ((bool)  tolua_toboolean(tolua_S,4,false));
  bool auto_delete = ((bool)  tolua_toboolean(tolua_S,5,true));
 {
  CEGUI::TreeItem* tolua_ret = (CEGUI::TreeItem*)  CEGUI::ceguiLua_createTreeItem(text,item_id,item_data,disabled,auto_delete);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TreeItem");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createTreeItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::FileStream */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FileStream_new00
static int tolua_CEGUI_CEGUI_FileStream_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::FileStream",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::FileStream* tolua_ret = (CEGUI::FileStream*)  new CEGUI::FileStream();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::FileStream");
 }
 }
 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  CEGUI::FileStream */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FileStream_new00_local
static int tolua_CEGUI_CEGUI_FileStream_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::FileStream",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::FileStream* tolua_ret = (CEGUI::FileStream*)  new CEGUI::FileStream();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::FileStream");
 }
 }
 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: is_open of class  CEGUI::FileStream */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FileStream_is_open00
static int tolua_CEGUI_CEGUI_FileStream_is_open00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FileStream",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FileStream* self = (CEGUI::FileStream*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'is_open'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->is_open();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'is_open'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CEGUI::ceguiLua_FileStream_open of class  CEGUI::FileStream */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FileStream_open00
static int tolua_CEGUI_CEGUI_FileStream_open00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FileStream",0,&tolua_err) ||
 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FileStream* self = (CEGUI::FileStream*)  tolua_tousertype(tolua_S,1,0);
  const char* filename = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CEGUI::ceguiLua_FileStream_open'",NULL);
#endif
 {
  CEGUI::ceguiLua_FileStream_open(self,filename);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'open'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: close of class  CEGUI::FileStream */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FileStream_close00
static int tolua_CEGUI_CEGUI_FileStream_close00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FileStream",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FileStream* self = (CEGUI::FileStream*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'close'",NULL);
#endif
 {
  self->close();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'close'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
int tolua_CEGUI_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,"CEGUI",0);
 tolua_beginmodule(tolua_S,"CEGUI");
  tolua_constant(tolua_S,"XREA_RETURN",CEGUI::XREA_RETURN);
  tolua_constant(tolua_S,"XREA_REPLACE",CEGUI::XREA_REPLACE);
  tolua_constant(tolua_S,"XREA_THROW",CEGUI::XREA_THROW);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Vector2","CEGUI::Vector2","",tolua_collect_CEGUI__Vector2);
  #else
  tolua_cclass(tolua_S,"Vector2","CEGUI::Vector2","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Vector2");
   tolua_variable(tolua_S,"x",tolua_get_CEGUI__Vector2_x,tolua_set_CEGUI__Vector2_x);
   tolua_variable(tolua_S,"y",tolua_get_CEGUI__Vector2_y,tolua_set_CEGUI__Vector2_y);
   tolua_function(tolua_S,".add",tolua_CEGUI_CEGUI_Vector2__add00);
   tolua_function(tolua_S,".sub",tolua_CEGUI_CEGUI_Vector2__sub00);
   tolua_function(tolua_S,".mul",tolua_CEGUI_CEGUI_Vector2__mul00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_Vector2__eq00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Vector2_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Vector2_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Vector2_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Vector2_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Vector2_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Vector2_new01_local);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static unsigned char B[] = {
  10, 67, 69, 71, 85, 73, 46, 80,111,105,110,116, 32, 61, 32,
    67, 69, 71, 85, 73, 46, 86,101, 99,116,111,114, 50,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 1");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Vector3","CEGUI::Vector3","",tolua_collect_CEGUI__Vector3);
  #else
  tolua_cclass(tolua_S,"Vector3","CEGUI::Vector3","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Vector3");
   tolua_variable(tolua_S,"x",tolua_get_CEGUI__Vector3_x,tolua_set_CEGUI__Vector3_x);
   tolua_variable(tolua_S,"y",tolua_get_CEGUI__Vector3_y,tolua_set_CEGUI__Vector3_y);
   tolua_variable(tolua_S,"z",tolua_get_CEGUI__Vector3_z,tolua_set_CEGUI__Vector3_z);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_Vector3__eq00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Vector3_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Vector3_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Vector3_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Vector3_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Vector3_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Vector3_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Size","CEGUI::Size","",tolua_collect_CEGUI__Size);
  #else
  tolua_cclass(tolua_S,"Size","CEGUI::Size","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Size");
   tolua_variable(tolua_S,"width",tolua_get_CEGUI__Size_width,tolua_set_CEGUI__Size_width);
   tolua_variable(tolua_S,"height",tolua_get_CEGUI__Size_height,tolua_set_CEGUI__Size_height);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_Size__eq00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Size_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Size_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Size_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Size_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Size_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Size_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Rect","CEGUI::Rect","",tolua_collect_CEGUI__Rect);
  #else
  tolua_cclass(tolua_S,"Rect","CEGUI::Rect","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Rect");
   tolua_variable(tolua_S,"top",tolua_get_CEGUI__Rect_top,tolua_set_CEGUI__Rect_top);
   tolua_variable(tolua_S,"bottom",tolua_get_CEGUI__Rect_bottom,tolua_set_CEGUI__Rect_bottom);
   tolua_variable(tolua_S,"left",tolua_get_CEGUI__Rect_left,tolua_set_CEGUI__Rect_left);
   tolua_variable(tolua_S,"right",tolua_get_CEGUI__Rect_right,tolua_set_CEGUI__Rect_right);
   tolua_function(tolua_S,"getPosition",tolua_CEGUI_CEGUI_Rect_getPosition00);
   tolua_function(tolua_S,"getWidth",tolua_CEGUI_CEGUI_Rect_getWidth00);
   tolua_function(tolua_S,"getHeight",tolua_CEGUI_CEGUI_Rect_getHeight00);
   tolua_function(tolua_S,"getSize",tolua_CEGUI_CEGUI_Rect_getSize00);
   tolua_function(tolua_S,"getIntersection",tolua_CEGUI_CEGUI_Rect_getIntersection00);
   tolua_function(tolua_S,"isPointInRect",tolua_CEGUI_CEGUI_Rect_isPointInRect00);
   tolua_function(tolua_S,"setPosition",tolua_CEGUI_CEGUI_Rect_setPosition00);
   tolua_function(tolua_S,"setWidth",tolua_CEGUI_CEGUI_Rect_setWidth00);
   tolua_function(tolua_S,"setHeight",tolua_CEGUI_CEGUI_Rect_setHeight00);
   tolua_function(tolua_S,"setSize",tolua_CEGUI_CEGUI_Rect_setSize00);
   tolua_function(tolua_S,"offset",tolua_CEGUI_CEGUI_Rect_offset00);
   tolua_function(tolua_S,"constrainSizeMax",tolua_CEGUI_CEGUI_Rect_constrainSizeMax00);
   tolua_function(tolua_S,"constrainSizeMin",tolua_CEGUI_CEGUI_Rect_constrainSizeMin00);
   tolua_function(tolua_S,"constrainSize",tolua_CEGUI_CEGUI_Rect_constrainSize00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_Rect__eq00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Rect_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Rect_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Rect_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Rect_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Rect_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Rect_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"colour","CEGUI::colour","",tolua_collect_CEGUI__colour);
  #else
  tolua_cclass(tolua_S,"colour","CEGUI::colour","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"colour");
   tolua_function(tolua_S,"getAlpha",tolua_CEGUI_CEGUI_colour_getAlpha00);
   tolua_function(tolua_S,"getRed",tolua_CEGUI_CEGUI_colour_getRed00);
   tolua_function(tolua_S,"getGreen",tolua_CEGUI_CEGUI_colour_getGreen00);
   tolua_function(tolua_S,"getBlue",tolua_CEGUI_CEGUI_colour_getBlue00);
   tolua_function(tolua_S,"getHue",tolua_CEGUI_CEGUI_colour_getHue00);
   tolua_function(tolua_S,"getSaturation",tolua_CEGUI_CEGUI_colour_getSaturation00);
   tolua_function(tolua_S,"getLumination",tolua_CEGUI_CEGUI_colour_getLumination00);
   tolua_function(tolua_S,"set",tolua_CEGUI_CEGUI_colour_set00);
   tolua_function(tolua_S,"setAlpha",tolua_CEGUI_CEGUI_colour_setAlpha00);
   tolua_function(tolua_S,"setRed",tolua_CEGUI_CEGUI_colour_setRed00);
   tolua_function(tolua_S,"setGreen",tolua_CEGUI_CEGUI_colour_setGreen00);
   tolua_function(tolua_S,"setBlue",tolua_CEGUI_CEGUI_colour_setBlue00);
   tolua_function(tolua_S,"setRGB",tolua_CEGUI_CEGUI_colour_setRGB00);
   tolua_function(tolua_S,"setHSL",tolua_CEGUI_CEGUI_colour_setHSL00);
   tolua_function(tolua_S,".add",tolua_CEGUI_CEGUI_colour__add00);
   tolua_function(tolua_S,".sub",tolua_CEGUI_CEGUI_colour__sub00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_colour__eq00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_colour_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_colour_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_colour_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_colour_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_colour_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_colour_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"ColourRect","CEGUI::ColourRect","",tolua_collect_CEGUI__ColourRect);
  #else
  tolua_cclass(tolua_S,"ColourRect","CEGUI::ColourRect","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ColourRect");
   tolua_variable(tolua_S,"top_left",tolua_get_CEGUI__ColourRect_top_left,tolua_set_CEGUI__ColourRect_top_left);
   tolua_variable(tolua_S,"top_right",tolua_get_CEGUI__ColourRect_top_right,tolua_set_CEGUI__ColourRect_top_right);
   tolua_variable(tolua_S,"bottom_left",tolua_get_CEGUI__ColourRect_bottom_left,tolua_set_CEGUI__ColourRect_bottom_left);
   tolua_variable(tolua_S,"bottom_right",tolua_get_CEGUI__ColourRect_bottom_right,tolua_set_CEGUI__ColourRect_bottom_right);
   tolua_function(tolua_S,"setAlpha",tolua_CEGUI_CEGUI_ColourRect_setAlpha00);
   tolua_function(tolua_S,"setTopAlpha",tolua_CEGUI_CEGUI_ColourRect_setTopAlpha00);
   tolua_function(tolua_S,"setBottomAlpha",tolua_CEGUI_CEGUI_ColourRect_setBottomAlpha00);
   tolua_function(tolua_S,"setLeftAlpha",tolua_CEGUI_CEGUI_ColourRect_setLeftAlpha00);
   tolua_function(tolua_S,"setRightAlpha",tolua_CEGUI_CEGUI_ColourRect_setRightAlpha00);
   tolua_function(tolua_S,"modulateAlpha",tolua_CEGUI_CEGUI_ColourRect_modulateAlpha00);
   tolua_function(tolua_S,"setColours",tolua_CEGUI_CEGUI_ColourRect_setColours00);
   tolua_function(tolua_S,"isMonochromatic",tolua_CEGUI_CEGUI_ColourRect_isMonochromatic00);
   tolua_function(tolua_S,"getSubRectangle",tolua_CEGUI_CEGUI_ColourRect_getSubRectangle00);
   tolua_function(tolua_S,"getColourAtPoint",tolua_CEGUI_CEGUI_ColourRect_getColourAtPoint00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_ColourRect_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_ColourRect_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_ColourRect_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_ColourRect_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_ColourRect_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_ColourRect_new01_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_ColourRect_new02);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_ColourRect_new02_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_ColourRect_new02_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"String","CEGUI::String","",tolua_collect_CEGUI__String);
  #else
  tolua_cclass(tolua_S,"String","CEGUI::String","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"String");
   tolua_variable(tolua_S,"npos",tolua_get_CEGUI__String_unsigned_npos,NULL);
   tolua_function(tolua_S,"size",tolua_CEGUI_CEGUI_String_size00);
   tolua_function(tolua_S,"length",tolua_CEGUI_CEGUI_String_length00);
   tolua_function(tolua_S,"empty",tolua_CEGUI_CEGUI_String_empty00);
   tolua_function(tolua_S,"capacity",tolua_CEGUI_CEGUI_String_capacity00);
   tolua_function(tolua_S,".seti",tolua_CEGUI_CEGUI_String__seti00);
   tolua_function(tolua_S,".geti",tolua_CEGUI_CEGUI_String__geti00);
   tolua_function(tolua_S,"at",tolua_CEGUI_CEGUI_String_at00);
   tolua_function(tolua_S,"c_str",tolua_CEGUI_CEGUI_String_c_str00);
   tolua_function(tolua_S,"reserve",tolua_CEGUI_CEGUI_String_reserve00);
   tolua_function(tolua_S,"resize",tolua_CEGUI_CEGUI_String_resize00);
   tolua_function(tolua_S,"resize",tolua_CEGUI_CEGUI_String_resize01);
   tolua_function(tolua_S,"clear",tolua_CEGUI_CEGUI_String_clear00);
   tolua_function(tolua_S,"erase",tolua_CEGUI_CEGUI_String_erase00);
   tolua_function(tolua_S,"erase",tolua_CEGUI_CEGUI_String_erase01);
   tolua_function(tolua_S,"replace",tolua_CEGUI_CEGUI_String_replace00);
   tolua_function(tolua_S,"swap",tolua_CEGUI_CEGUI_String_swap00);
   tolua_function(tolua_S,"insert",tolua_CEGUI_CEGUI_String_insert00);
   tolua_function(tolua_S,"find",tolua_CEGUI_CEGUI_String_find00);
   tolua_function(tolua_S,"rfind",tolua_CEGUI_CEGUI_String_rfind00);
   tolua_function(tolua_S,"find",tolua_CEGUI_CEGUI_String_find01);
   tolua_function(tolua_S,"rfind",tolua_CEGUI_CEGUI_String_rfind01);
   tolua_function(tolua_S,"substr",tolua_CEGUI_CEGUI_String_substr00);
   tolua_function(tolua_S,"push_back",tolua_CEGUI_CEGUI_String_push_back00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_String_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_String_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_String_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_String_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_String_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_String_new01_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_String_new02);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_String_new02_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_String_new02_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_String_new03);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_String_new03_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_String_new03_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"UDim","CEGUI::UDim","",tolua_collect_CEGUI__UDim);
  #else
  tolua_cclass(tolua_S,"UDim","CEGUI::UDim","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"UDim");
   tolua_variable(tolua_S,"scale",tolua_get_CEGUI__UDim_scale,tolua_set_CEGUI__UDim_scale);
   tolua_variable(tolua_S,"offset",tolua_get_CEGUI__UDim_offset,tolua_set_CEGUI__UDim_offset);
   tolua_function(tolua_S,"asAbsolute",tolua_CEGUI_CEGUI_UDim_asAbsolute00);
   tolua_function(tolua_S,"asRelative",tolua_CEGUI_CEGUI_UDim_asRelative00);
   tolua_function(tolua_S,".add",tolua_CEGUI_CEGUI_UDim__add00);
   tolua_function(tolua_S,".sub",tolua_CEGUI_CEGUI_UDim__sub00);
   tolua_function(tolua_S,".div",tolua_CEGUI_CEGUI_UDim__div00);
   tolua_function(tolua_S,".mul",tolua_CEGUI_CEGUI_UDim__mul00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_UDim__eq00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_UDim_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_UDim_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_UDim_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_UDim_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_UDim_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_UDim_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"UVector2","CEGUI::UVector2","",tolua_collect_CEGUI__UVector2);
  #else
  tolua_cclass(tolua_S,"UVector2","CEGUI::UVector2","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"UVector2");
   tolua_variable(tolua_S,"x",tolua_get_CEGUI__UVector2_x,tolua_set_CEGUI__UVector2_x);
   tolua_variable(tolua_S,"y",tolua_get_CEGUI__UVector2_y,tolua_set_CEGUI__UVector2_y);
   tolua_function(tolua_S,"asAbsolute",tolua_CEGUI_CEGUI_UVector2_asAbsolute00);
   tolua_function(tolua_S,"asRelative",tolua_CEGUI_CEGUI_UVector2_asRelative00);
   tolua_function(tolua_S,".add",tolua_CEGUI_CEGUI_UVector2__add00);
   tolua_function(tolua_S,".sub",tolua_CEGUI_CEGUI_UVector2__sub00);
   tolua_function(tolua_S,".div",tolua_CEGUI_CEGUI_UVector2__div00);
   tolua_function(tolua_S,".mul",tolua_CEGUI_CEGUI_UVector2__mul00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_UVector2__eq00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_UVector2_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_UVector2_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_UVector2_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_UVector2_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_UVector2_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_UVector2_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"URect","CEGUI::URect","",tolua_collect_CEGUI__URect);
  #else
  tolua_cclass(tolua_S,"URect","CEGUI::URect","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"URect");
   tolua_variable(tolua_S,"min",tolua_get_CEGUI__URect_min,tolua_set_CEGUI__URect_min);
   tolua_variable(tolua_S,"max",tolua_get_CEGUI__URect_max,tolua_set_CEGUI__URect_max);
   tolua_function(tolua_S,"asAbsolute",tolua_CEGUI_CEGUI_URect_asAbsolute00);
   tolua_function(tolua_S,"asRelative",tolua_CEGUI_CEGUI_URect_asRelative00);
   tolua_function(tolua_S,"getPosition",tolua_CEGUI_CEGUI_URect_getPosition00);
   tolua_function(tolua_S,"getSize",tolua_CEGUI_CEGUI_URect_getSize00);
   tolua_function(tolua_S,"getWidth",tolua_CEGUI_CEGUI_URect_getWidth00);
   tolua_function(tolua_S,"getHeight",tolua_CEGUI_CEGUI_URect_getHeight00);
   tolua_function(tolua_S,"setPosition",tolua_CEGUI_CEGUI_URect_setPosition00);
   tolua_function(tolua_S,"setSize",tolua_CEGUI_CEGUI_URect_setSize00);
   tolua_function(tolua_S,"setWidth",tolua_CEGUI_CEGUI_URect_setWidth00);
   tolua_function(tolua_S,"setHeight",tolua_CEGUI_CEGUI_URect_setHeight00);
   tolua_function(tolua_S,"offset",tolua_CEGUI_CEGUI_URect_offset00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_URect_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_URect_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_URect_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_URect_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_URect_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_URect_new01_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_URect_new02);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_URect_new02_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_URect_new02_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"UBox","CEGUI::UBox","",tolua_collect_CEGUI__UBox);
  #else
  tolua_cclass(tolua_S,"UBox","CEGUI::UBox","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"UBox");
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_UBox_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_UBox_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_UBox_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_UBox_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_UBox_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_UBox_new01_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_UBox_new02);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_UBox_new02_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_UBox_new02_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_UBox_new03);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_UBox_new03_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_UBox_new03_local);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_UBox__eq00);
   tolua_variable(tolua_S,"top",tolua_get_CEGUI__UBox_top,tolua_set_CEGUI__UBox_top);
   tolua_variable(tolua_S,"left",tolua_get_CEGUI__UBox_left,tolua_set_CEGUI__UBox_left);
   tolua_variable(tolua_S,"bottom",tolua_get_CEGUI__UBox_bottom,tolua_set_CEGUI__UBox_bottom);
   tolua_variable(tolua_S,"right",tolua_get_CEGUI__UBox_right,tolua_set_CEGUI__UBox_right);
  tolua_endmodule(tolua_S);
  tolua_constant(tolua_S,"Errors",CEGUI::Errors);
  tolua_constant(tolua_S,"Warnings",CEGUI::Warnings);
  tolua_constant(tolua_S,"Standard",CEGUI::Standard);
  tolua_constant(tolua_S,"Informative",CEGUI::Informative);
  tolua_constant(tolua_S,"Insane",CEGUI::Insane);
  tolua_cclass(tolua_S,"Logger","CEGUI::Logger","",NULL);
  tolua_beginmodule(tolua_S,"Logger");
   tolua_function(tolua_S,"getSingleton",tolua_CEGUI_CEGUI_Logger_getSingleton00);
   tolua_function(tolua_S,"setLoggingLevel",tolua_CEGUI_CEGUI_Logger_setLoggingLevel00);
   tolua_function(tolua_S,"getLoggingLevel",tolua_CEGUI_CEGUI_Logger_getLoggingLevel00);
   tolua_function(tolua_S,"logEvent",tolua_CEGUI_CEGUI_Logger_logEvent00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Font","CEGUI::Font","",NULL);
  tolua_beginmodule(tolua_S,"Font");
   tolua_function(tolua_S,"setProperty",tolua_CEGUI_CEGUI_Font_setProperty00);
   tolua_function(tolua_S,"getProperty",tolua_CEGUI_CEGUI_Font_getProperty00);
   tolua_function(tolua_S,"getPropertyDefault",tolua_CEGUI_CEGUI_Font_getPropertyDefault00);
   tolua_function(tolua_S,"getPropertyHelp",tolua_CEGUI_CEGUI_Font_getPropertyHelp00);
   tolua_function(tolua_S,"isPropertyPresent",tolua_CEGUI_CEGUI_Font_isPropertyPresent00);
   tolua_function(tolua_S,"isPropertyDefault",tolua_CEGUI_CEGUI_Font_isPropertyDefault00);
   tolua_function(tolua_S,"getPropertyIterator",tolua_CEGUI_CEGUI_Font_getPropertyIterator00);
   tolua_function(tolua_S,"setDefaultResourceGroup",tolua_CEGUI_CEGUI_Font_setDefaultResourceGroup00);
   tolua_function(tolua_S,"getDefaultResourceGroup",tolua_CEGUI_CEGUI_Font_getDefaultResourceGroup00);
   tolua_function(tolua_S,"isCodepointAvailable",tolua_CEGUI_CEGUI_Font_isCodepointAvailable00);
   tolua_function(tolua_S,"setNativeResolution",tolua_CEGUI_CEGUI_Font_setNativeResolution00);
   tolua_function(tolua_S,"notifyDisplaySizeChanged",tolua_CEGUI_CEGUI_Font_notifyDisplaySizeChanged00);
   tolua_function(tolua_S,"getTextExtent",tolua_CEGUI_CEGUI_Font_getTextExtent00);
   tolua_function(tolua_S,"getLineSpacing",tolua_CEGUI_CEGUI_Font_getLineSpacing00);
   tolua_function(tolua_S,"getFontHeight",tolua_CEGUI_CEGUI_Font_getFontHeight00);
   tolua_function(tolua_S,"getCharAtPixel",tolua_CEGUI_CEGUI_Font_getCharAtPixel00);
   tolua_function(tolua_S,"getCharAtPixel",tolua_CEGUI_CEGUI_Font_getCharAtPixel01);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"FontManager","CEGUI::FontManager","",NULL);
  tolua_beginmodule(tolua_S,"FontManager");
   tolua_function(tolua_S,"getSingleton",tolua_CEGUI_CEGUI_FontManager_getSingleton00);
   tolua_function(tolua_S,"create",tolua_CEGUI_CEGUI_FontManager_create00);
   tolua_function(tolua_S,"createFreeTypeFont",tolua_CEGUI_CEGUI_FontManager_createFreeTypeFont00);
   tolua_function(tolua_S,"createPixmapFont",tolua_CEGUI_CEGUI_FontManager_createPixmapFont00);
   tolua_function(tolua_S,"destroy",tolua_CEGUI_CEGUI_FontManager_destroy00);
   tolua_function(tolua_S,"destroy",tolua_CEGUI_CEGUI_FontManager_destroy01);
   tolua_function(tolua_S,"destroyAll",tolua_CEGUI_CEGUI_FontManager_destroyAll00);
   tolua_function(tolua_S,"isDefined",tolua_CEGUI_CEGUI_FontManager_isDefined00);
   tolua_function(tolua_S,"get",tolua_CEGUI_CEGUI_FontManager_get00);
   tolua_function(tolua_S,"notifyDisplaySizeChanged",tolua_CEGUI_CEGUI_FontManager_notifyDisplaySizeChanged00);
   tolua_function(tolua_S,"getIterator",tolua_CEGUI_CEGUI_FontManager_getIterator00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Image","CEGUI::Image","",tolua_collect_CEGUI__Image);
  #else
  tolua_cclass(tolua_S,"Image","CEGUI::Image","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Image");
   tolua_function(tolua_S,"getSize",tolua_CEGUI_CEGUI_Image_getSize00);
   tolua_function(tolua_S,"getWidth",tolua_CEGUI_CEGUI_Image_getWidth00);
   tolua_function(tolua_S,"getHeight",tolua_CEGUI_CEGUI_Image_getHeight00);
   tolua_function(tolua_S,"getOffsets",tolua_CEGUI_CEGUI_Image_getOffsets00);
   tolua_function(tolua_S,"getOffsetX",tolua_CEGUI_CEGUI_Image_getOffsetX00);
   tolua_function(tolua_S,"getOffsetY",tolua_CEGUI_CEGUI_Image_getOffsetY00);
   tolua_function(tolua_S,"getName",tolua_CEGUI_CEGUI_Image_getName00);
   tolua_function(tolua_S,"getImagesetName",tolua_CEGUI_CEGUI_Image_getImagesetName00);
   tolua_function(tolua_S,"getSourceTextureArea",tolua_CEGUI_CEGUI_Image_getSourceTextureArea00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Imageset","CEGUI::Imageset","",NULL);
  tolua_beginmodule(tolua_S,"Imageset");
   tolua_function(tolua_S,"getTexture",tolua_CEGUI_CEGUI_Imageset_getTexture00);
   tolua_function(tolua_S,"getName",tolua_CEGUI_CEGUI_Imageset_getName00);
   tolua_function(tolua_S,"getImageCount",tolua_CEGUI_CEGUI_Imageset_getImageCount00);
   tolua_function(tolua_S,"isImageDefined",tolua_CEGUI_CEGUI_Imageset_isImageDefined00);
   tolua_function(tolua_S,"getImage",tolua_CEGUI_CEGUI_Imageset_getImage00);
   tolua_function(tolua_S,"undefineImage",tolua_CEGUI_CEGUI_Imageset_undefineImage00);
   tolua_function(tolua_S,"undefineAllImages",tolua_CEGUI_CEGUI_Imageset_undefineAllImages00);
   tolua_function(tolua_S,"getImageSize",tolua_CEGUI_CEGUI_Imageset_getImageSize00);
   tolua_function(tolua_S,"getImageWidth",tolua_CEGUI_CEGUI_Imageset_getImageWidth00);
   tolua_function(tolua_S,"getImageHeight",tolua_CEGUI_CEGUI_Imageset_getImageHeight00);
   tolua_function(tolua_S,"getImageOffset",tolua_CEGUI_CEGUI_Imageset_getImageOffset00);
   tolua_function(tolua_S,"getImageOffsetX",tolua_CEGUI_CEGUI_Imageset_getImageOffsetX00);
   tolua_function(tolua_S,"getImageOffsetY",tolua_CEGUI_CEGUI_Imageset_getImageOffsetY00);
   tolua_function(tolua_S,"defineImage",tolua_CEGUI_CEGUI_Imageset_defineImage00);
   tolua_function(tolua_S,"defineImage",tolua_CEGUI_CEGUI_Imageset_defineImage01);
   tolua_function(tolua_S,"isAutoScaled",tolua_CEGUI_CEGUI_Imageset_isAutoScaled00);
   tolua_function(tolua_S,"setAutoScalingEnabled",tolua_CEGUI_CEGUI_Imageset_setAutoScalingEnabled00);
   tolua_function(tolua_S,"getNativeResolution",tolua_CEGUI_CEGUI_Imageset_getNativeResolution00);
   tolua_function(tolua_S,"setNativeResolution",tolua_CEGUI_CEGUI_Imageset_setNativeResolution00);
   tolua_function(tolua_S,"notifyDisplaySizeChanged",tolua_CEGUI_CEGUI_Imageset_notifyDisplaySizeChanged00);
   tolua_function(tolua_S,"getIterator",tolua_CEGUI_CEGUI_Imageset_getIterator00);
   tolua_function(tolua_S,"setDefaultResourceGroup",tolua_CEGUI_CEGUI_Imageset_setDefaultResourceGroup00);
   tolua_function(tolua_S,"getDefaultResourceGroup",tolua_CEGUI_CEGUI_Imageset_getDefaultResourceGroup00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ImagesetManager","CEGUI::ImagesetManager","",NULL);
  tolua_beginmodule(tolua_S,"ImagesetManager");
   tolua_function(tolua_S,"getSingleton",tolua_CEGUI_CEGUI_ImagesetManager_getSingleton00);
   tolua_function(tolua_S,"create",tolua_CEGUI_CEGUI_ImagesetManager_create00);
   tolua_function(tolua_S,"create",tolua_CEGUI_CEGUI_ImagesetManager_create01);
   tolua_function(tolua_S,"createFromImageFile",tolua_CEGUI_CEGUI_ImagesetManager_createFromImageFile00);
   tolua_function(tolua_S,"destroy",tolua_CEGUI_CEGUI_ImagesetManager_destroy00);
   tolua_function(tolua_S,"destroy",tolua_CEGUI_CEGUI_ImagesetManager_destroy01);
   tolua_function(tolua_S,"destroyAll",tolua_CEGUI_CEGUI_ImagesetManager_destroyAll00);
   tolua_function(tolua_S,"get",tolua_CEGUI_CEGUI_ImagesetManager_get00);
   tolua_function(tolua_S,"isDefined",tolua_CEGUI_CEGUI_ImagesetManager_isDefined00);
   tolua_function(tolua_S,"notifyDisplaySizeChanged",tolua_CEGUI_CEGUI_ImagesetManager_notifyDisplaySizeChanged00);
   tolua_function(tolua_S,"getIterator",tolua_CEGUI_CEGUI_ImagesetManager_getIterator00);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static unsigned char B[] = {
  10,102,117,110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73,
    46,105,116,101,114, 97,116,111,114, 95,105,109,112,108, 95,
   110,101,120,116, 40,112, 41, 10,105,102, 32,112, 58,105,115,
    65,116, 69,110,100, 40, 41, 32,116,104,101,110, 10,114,101,
   116,117,114,110, 32,110,105,108, 59, 10,101,110,100, 10,108,
   111, 99, 97,108, 32,107, 44,118, 32, 61, 32,112, 58,107,101,
   121, 40, 41, 44, 32,112, 58,118, 97,108,117,101, 40, 41, 59,
    10,112, 58,110,101,120,116, 40, 41, 59, 10,114,101,116,117,
   114,110, 32,107, 44,118, 59, 10,101,110,100, 10,102,117,110,
    99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,105,116,101,
   114, 97,116,111,114, 95,105,109,112,108, 40,115,101,108,102,
    41, 10,114,101,116,117,114,110, 32, 67, 69, 71, 85, 73, 46,
   105,116,101,114, 97,116,111,114, 95,105,109,112,108, 95,110,
   101,120,116, 44, 32,115,101,108,102, 59, 10,101,110,100,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 2");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  tolua_cclass(tolua_S,"Property","CEGUI::Property","",NULL);
  tolua_beginmodule(tolua_S,"Property");
   tolua_function(tolua_S,"getHelp",tolua_CEGUI_CEGUI_Property_getHelp00);
   tolua_function(tolua_S,"getName",tolua_CEGUI_CEGUI_Property_getName00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"PropertyIterator","CEGUI::PropertyIterator","",tolua_collect_CEGUI__PropertyIterator);
  #else
  tolua_cclass(tolua_S,"PropertyIterator","CEGUI::PropertyIterator","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"PropertyIterator");
   tolua_function(tolua_S,"key",tolua_CEGUI_CEGUI_PropertyIterator_key00);
   tolua_function(tolua_S,"value",tolua_CEGUI_CEGUI_PropertyIterator_value00);
   tolua_function(tolua_S,"isAtEnd",tolua_CEGUI_CEGUI_PropertyIterator_isAtEnd00);
   tolua_function(tolua_S,"isAtStart",tolua_CEGUI_CEGUI_PropertyIterator_isAtStart00);
   tolua_function(tolua_S,"next",tolua_CEGUI_CEGUI_PropertyIterator_next00);
   tolua_function(tolua_S,"previous",tolua_CEGUI_CEGUI_PropertyIterator_previous00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_PropertyIterator__eq00);
   tolua_function(tolua_S,"toStart",tolua_CEGUI_CEGUI_PropertyIterator_toStart00);
   tolua_function(tolua_S,"toEnd",tolua_CEGUI_CEGUI_PropertyIterator_toEnd00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_PropertyIterator_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_PropertyIterator_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_PropertyIterator_new00_local);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static unsigned char B[] = {
  10, 67, 69, 71, 85, 73, 46, 80,114,111,112,101,114,116,121,
    73,116,101,114, 97,116,111,114, 46,105,116,101,114, 97,116,
   111,114, 32, 61, 32, 67, 69, 71, 85, 73, 46,105,116,101,114,
    97,116,111,114, 95,105,109,112,108, 59,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 3");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  #ifdef __cplusplus
  tolua_cclass(tolua_S,"EventIterator","CEGUI::EventIterator","",tolua_collect_CEGUI__EventIterator);
  #else
  tolua_cclass(tolua_S,"EventIterator","CEGUI::EventIterator","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"EventIterator");
   tolua_function(tolua_S,"key",tolua_CEGUI_CEGUI_EventIterator_key00);
   tolua_function(tolua_S,"value",tolua_CEGUI_CEGUI_EventIterator_value00);
   tolua_function(tolua_S,"isAtEnd",tolua_CEGUI_CEGUI_EventIterator_isAtEnd00);
   tolua_function(tolua_S,"isAtStart",tolua_CEGUI_CEGUI_EventIterator_isAtStart00);
   tolua_function(tolua_S,"next",tolua_CEGUI_CEGUI_EventIterator_next00);
   tolua_function(tolua_S,"previous",tolua_CEGUI_CEGUI_EventIterator_previous00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_EventIterator__eq00);
   tolua_function(tolua_S,"toStart",tolua_CEGUI_CEGUI_EventIterator_toStart00);
   tolua_function(tolua_S,"toEnd",tolua_CEGUI_CEGUI_EventIterator_toEnd00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_EventIterator_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_EventIterator_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_EventIterator_new00_local);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static unsigned char B[] = {
  10, 67, 69, 71, 85, 73, 46, 69,118,101,110,116, 73,116,101,
   114, 97,116,111,114, 46,105,116,101,114, 97,116,111,114, 32,
    61, 32, 67, 69, 71, 85, 73, 46,105,116,101,114, 97,116,111,
   114, 95,105,109,112,108, 59,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 4");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  #ifdef __cplusplus
  tolua_cclass(tolua_S,"WindowIterator","CEGUI::WindowIterator","",tolua_collect_CEGUI__WindowIterator);
  #else
  tolua_cclass(tolua_S,"WindowIterator","CEGUI::WindowIterator","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"WindowIterator");
   tolua_function(tolua_S,"key",tolua_CEGUI_CEGUI_WindowIterator_key00);
   tolua_function(tolua_S,"value",tolua_CEGUI_CEGUI_WindowIterator_value00);
   tolua_function(tolua_S,"isAtEnd",tolua_CEGUI_CEGUI_WindowIterator_isAtEnd00);
   tolua_function(tolua_S,"isAtStart",tolua_CEGUI_CEGUI_WindowIterator_isAtStart00);
   tolua_function(tolua_S,"next",tolua_CEGUI_CEGUI_WindowIterator_next00);
   tolua_function(tolua_S,"previous",tolua_CEGUI_CEGUI_WindowIterator_previous00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_WindowIterator__eq00);
   tolua_function(tolua_S,"toStart",tolua_CEGUI_CEGUI_WindowIterator_toStart00);
   tolua_function(tolua_S,"toEnd",tolua_CEGUI_CEGUI_WindowIterator_toEnd00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_WindowIterator_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_WindowIterator_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_WindowIterator_new00_local);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static unsigned char B[] = {
  10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 73,116,
   101,114, 97,116,111,114, 46,105,116,101,114, 97,116,111,114,
    32, 61, 32, 67, 69, 71, 85, 73, 46,105,116,101,114, 97,116,
   111,114, 95,105,109,112,108, 59,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 5");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  #ifdef __cplusplus
  tolua_cclass(tolua_S,"WindowFactoryIterator","CEGUI::WindowFactoryIterator","",tolua_collect_CEGUI__WindowFactoryIterator);
  #else
  tolua_cclass(tolua_S,"WindowFactoryIterator","CEGUI::WindowFactoryIterator","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"WindowFactoryIterator");
   tolua_function(tolua_S,"key",tolua_CEGUI_CEGUI_WindowFactoryIterator_key00);
   tolua_function(tolua_S,"value",tolua_CEGUI_CEGUI_WindowFactoryIterator_value00);
   tolua_function(tolua_S,"isAtEnd",tolua_CEGUI_CEGUI_WindowFactoryIterator_isAtEnd00);
   tolua_function(tolua_S,"isAtStart",tolua_CEGUI_CEGUI_WindowFactoryIterator_isAtStart00);
   tolua_function(tolua_S,"next",tolua_CEGUI_CEGUI_WindowFactoryIterator_next00);
   tolua_function(tolua_S,"previous",tolua_CEGUI_CEGUI_WindowFactoryIterator_previous00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_WindowFactoryIterator__eq00);
   tolua_function(tolua_S,"toStart",tolua_CEGUI_CEGUI_WindowFactoryIterator_toStart00);
   tolua_function(tolua_S,"toEnd",tolua_CEGUI_CEGUI_WindowFactoryIterator_toEnd00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_WindowFactoryIterator_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_WindowFactoryIterator_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_WindowFactoryIterator_new00_local);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static unsigned char B[] = {
  10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 70, 97,
    99,116,111,114,121, 73,116,101,114, 97,116,111,114, 46,105,
   116,101,114, 97,116,111,114, 32, 61, 32, 67, 69, 71, 85, 73,
    46,105,116,101,114, 97,116,111,114, 95,105,109,112,108, 59,
   32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 6");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  #ifdef __cplusplus
  tolua_cclass(tolua_S,"FalagardMappingIterator","CEGUI::FalagardMappingIterator","",tolua_collect_CEGUI__FalagardMappingIterator);
  #else
  tolua_cclass(tolua_S,"FalagardMappingIterator","CEGUI::FalagardMappingIterator","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"FalagardMappingIterator");
   tolua_function(tolua_S,"key",tolua_CEGUI_CEGUI_FalagardMappingIterator_key00);
   tolua_function(tolua_S,"value",tolua_CEGUI_CEGUI_FalagardMappingIterator_value00);
   tolua_function(tolua_S,"isAtEnd",tolua_CEGUI_CEGUI_FalagardMappingIterator_isAtEnd00);
   tolua_function(tolua_S,"isAtStart",tolua_CEGUI_CEGUI_FalagardMappingIterator_isAtStart00);
   tolua_function(tolua_S,"next",tolua_CEGUI_CEGUI_FalagardMappingIterator_next00);
   tolua_function(tolua_S,"previous",tolua_CEGUI_CEGUI_FalagardMappingIterator_previous00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_FalagardMappingIterator__eq00);
   tolua_function(tolua_S,"toStart",tolua_CEGUI_CEGUI_FalagardMappingIterator_toStart00);
   tolua_function(tolua_S,"toEnd",tolua_CEGUI_CEGUI_FalagardMappingIterator_toEnd00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_FalagardMappingIterator_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_FalagardMappingIterator_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_FalagardMappingIterator_new00_local);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static unsigned char B[] = {
  10, 67, 69, 71, 85, 73, 46, 70, 97,108, 97,103, 97,114,100,
    77, 97,112,112,105,110,103, 73,116,101,114, 97,116,111,114,
    46,105,116,101,114, 97,116,111,114, 32, 61, 32, 67, 69, 71,
    85, 73, 46,105,116,101,114, 97,116,111,114, 95,105,109,112,
   108, 59,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 7");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  #ifdef __cplusplus
  tolua_cclass(tolua_S,"ImagesetIterator","CEGUI::ImagesetIterator","",tolua_collect_CEGUI__ImagesetIterator);
  #else
  tolua_cclass(tolua_S,"ImagesetIterator","CEGUI::ImagesetIterator","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ImagesetIterator");
   tolua_function(tolua_S,"key",tolua_CEGUI_CEGUI_ImagesetIterator_key00);
   tolua_function(tolua_S,"value",tolua_CEGUI_CEGUI_ImagesetIterator_value00);
   tolua_function(tolua_S,"isAtEnd",tolua_CEGUI_CEGUI_ImagesetIterator_isAtEnd00);
   tolua_function(tolua_S,"isAtStart",tolua_CEGUI_CEGUI_ImagesetIterator_isAtStart00);
   tolua_function(tolua_S,"next",tolua_CEGUI_CEGUI_ImagesetIterator_next00);
   tolua_function(tolua_S,"previous",tolua_CEGUI_CEGUI_ImagesetIterator_previous00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_ImagesetIterator__eq00);
   tolua_function(tolua_S,"toStart",tolua_CEGUI_CEGUI_ImagesetIterator_toStart00);
   tolua_function(tolua_S,"toEnd",tolua_CEGUI_CEGUI_ImagesetIterator_toEnd00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_ImagesetIterator_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_ImagesetIterator_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_ImagesetIterator_new00_local);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static unsigned char B[] = {
  10, 67, 69, 71, 85, 73, 46, 73,109, 97,103,101,115,101,116,
    73,116,101,114, 97,116,111,114, 46,105,116,101,114, 97,116,
   111,114, 32, 61, 32, 67, 69, 71, 85, 73, 46,105,116,101,114,
    97,116,111,114, 95,105,109,112,108, 59,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 8");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  #ifdef __cplusplus
  tolua_cclass(tolua_S,"ImageIterator","CEGUI::ImageIterator","",tolua_collect_CEGUI__ImageIterator);
  #else
  tolua_cclass(tolua_S,"ImageIterator","CEGUI::ImageIterator","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ImageIterator");
   tolua_function(tolua_S,"key",tolua_CEGUI_CEGUI_ImageIterator_key00);
   tolua_function(tolua_S,"value",tolua_CEGUI_CEGUI_ImageIterator_value00);
   tolua_function(tolua_S,"isAtEnd",tolua_CEGUI_CEGUI_ImageIterator_isAtEnd00);
   tolua_function(tolua_S,"isAtStart",tolua_CEGUI_CEGUI_ImageIterator_isAtStart00);
   tolua_function(tolua_S,"next",tolua_CEGUI_CEGUI_ImageIterator_next00);
   tolua_function(tolua_S,"previous",tolua_CEGUI_CEGUI_ImageIterator_previous00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_ImageIterator__eq00);
   tolua_function(tolua_S,"toStart",tolua_CEGUI_CEGUI_ImageIterator_toStart00);
   tolua_function(tolua_S,"toEnd",tolua_CEGUI_CEGUI_ImageIterator_toEnd00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_ImageIterator_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_ImageIterator_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_ImageIterator_new00_local);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static unsigned char B[] = {
  10, 67, 69, 71, 85, 73, 46, 73,109, 97,103,101, 73,116,101,
   114, 97,116,111,114, 46,105,116,101,114, 97,116,111,114, 32,
    61, 32, 67, 69, 71, 85, 73, 46,105,116,101,114, 97,116,111,
   114, 95,105,109,112,108, 59,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 9");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  #ifdef __cplusplus
  tolua_cclass(tolua_S,"SchemeIterator","CEGUI::SchemeIterator","",tolua_collect_CEGUI__SchemeIterator);
  #else
  tolua_cclass(tolua_S,"SchemeIterator","CEGUI::SchemeIterator","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"SchemeIterator");
   tolua_function(tolua_S,"key",tolua_CEGUI_CEGUI_SchemeIterator_key00);
   tolua_function(tolua_S,"value",tolua_CEGUI_CEGUI_SchemeIterator_value00);
   tolua_function(tolua_S,"isAtEnd",tolua_CEGUI_CEGUI_SchemeIterator_isAtEnd00);
   tolua_function(tolua_S,"isAtStart",tolua_CEGUI_CEGUI_SchemeIterator_isAtStart00);
   tolua_function(tolua_S,"next",tolua_CEGUI_CEGUI_SchemeIterator_next00);
   tolua_function(tolua_S,"previous",tolua_CEGUI_CEGUI_SchemeIterator_previous00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_SchemeIterator__eq00);
   tolua_function(tolua_S,"toStart",tolua_CEGUI_CEGUI_SchemeIterator_toStart00);
   tolua_function(tolua_S,"toEnd",tolua_CEGUI_CEGUI_SchemeIterator_toEnd00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_SchemeIterator_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_SchemeIterator_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_SchemeIterator_new00_local);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static unsigned char B[] = {
  10, 67, 69, 71, 85, 73, 46, 83, 99,104,101,109,101, 73,116,
   101,114, 97,116,111,114, 46,105,116,101,114, 97,116,111,114,
    32, 61, 32, 67, 69, 71, 85, 73, 46,105,116,101,114, 97,116,
   111,114, 95,105,109,112,108, 59,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 10");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  #ifdef __cplusplus
  tolua_cclass(tolua_S,"FontIterator","CEGUI::FontIterator","",tolua_collect_CEGUI__FontIterator);
  #else
  tolua_cclass(tolua_S,"FontIterator","CEGUI::FontIterator","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"FontIterator");
   tolua_function(tolua_S,"key",tolua_CEGUI_CEGUI_FontIterator_key00);
   tolua_function(tolua_S,"value",tolua_CEGUI_CEGUI_FontIterator_value00);
   tolua_function(tolua_S,"isAtEnd",tolua_CEGUI_CEGUI_FontIterator_isAtEnd00);
   tolua_function(tolua_S,"isAtStart",tolua_CEGUI_CEGUI_FontIterator_isAtStart00);
   tolua_function(tolua_S,"next",tolua_CEGUI_CEGUI_FontIterator_next00);
   tolua_function(tolua_S,"previous",tolua_CEGUI_CEGUI_FontIterator_previous00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_FontIterator__eq00);
   tolua_function(tolua_S,"toStart",tolua_CEGUI_CEGUI_FontIterator_toStart00);
   tolua_function(tolua_S,"toEnd",tolua_CEGUI_CEGUI_FontIterator_toEnd00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_FontIterator_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_FontIterator_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_FontIterator_new00_local);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static unsigned char B[] = {
  10, 67, 69, 71, 85, 73, 46, 70,111,110,116, 73,116,101,114,
    97,116,111,114, 46,105,116,101,114, 97,116,111,114, 32, 61,
    32, 67, 69, 71, 85, 73, 46,105,116,101,114, 97,116,111,114,
    95,105,109,112,108, 59,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 11");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  tolua_module(tolua_S,"Key",0);
  tolua_beginmodule(tolua_S,"Key");
   tolua_constant(tolua_S,"Escape",CEGUI::Key::Escape);
   tolua_constant(tolua_S,"One",CEGUI::Key::One);
   tolua_constant(tolua_S,"Two",CEGUI::Key::Two);
   tolua_constant(tolua_S,"Three",CEGUI::Key::Three);
   tolua_constant(tolua_S,"Four",CEGUI::Key::Four);
   tolua_constant(tolua_S,"Five",CEGUI::Key::Five);
   tolua_constant(tolua_S,"Six",CEGUI::Key::Six);
   tolua_constant(tolua_S,"Seven",CEGUI::Key::Seven);
   tolua_constant(tolua_S,"Eight",CEGUI::Key::Eight);
   tolua_constant(tolua_S,"Nine",CEGUI::Key::Nine);
   tolua_constant(tolua_S,"Zero",CEGUI::Key::Zero);
   tolua_constant(tolua_S,"Minus",CEGUI::Key::Minus);
   tolua_constant(tolua_S,"Equals",CEGUI::Key::Equals);
   tolua_constant(tolua_S,"Backspace",CEGUI::Key::Backspace);
   tolua_constant(tolua_S,"Tab",CEGUI::Key::Tab);
   tolua_constant(tolua_S,"Q",CEGUI::Key::Q);
   tolua_constant(tolua_S,"W",CEGUI::Key::W);
   tolua_constant(tolua_S,"E",CEGUI::Key::E);
   tolua_constant(tolua_S,"R",CEGUI::Key::R);
   tolua_constant(tolua_S,"T",CEGUI::Key::T);
   tolua_constant(tolua_S,"Y",CEGUI::Key::Y);
   tolua_constant(tolua_S,"U",CEGUI::Key::U);
   tolua_constant(tolua_S,"I",CEGUI::Key::I);
   tolua_constant(tolua_S,"O",CEGUI::Key::O);
   tolua_constant(tolua_S,"P",CEGUI::Key::P);
   tolua_constant(tolua_S,"LeftBracket",CEGUI::Key::LeftBracket);
   tolua_constant(tolua_S,"RightBracket",CEGUI::Key::RightBracket);
   tolua_constant(tolua_S,"Return",CEGUI::Key::Return);
   tolua_constant(tolua_S,"LeftControl",CEGUI::Key::LeftControl);
   tolua_constant(tolua_S,"A",CEGUI::Key::A);
   tolua_constant(tolua_S,"S",CEGUI::Key::S);
   tolua_constant(tolua_S,"D",CEGUI::Key::D);
   tolua_constant(tolua_S,"F",CEGUI::Key::F);
   tolua_constant(tolua_S,"G",CEGUI::Key::G);
   tolua_constant(tolua_S,"H",CEGUI::Key::H);
   tolua_constant(tolua_S,"J",CEGUI::Key::J);
   tolua_constant(tolua_S,"K",CEGUI::Key::K);
   tolua_constant(tolua_S,"L",CEGUI::Key::L);
   tolua_constant(tolua_S,"Semicolon",CEGUI::Key::Semicolon);
   tolua_constant(tolua_S,"Apostrophe",CEGUI::Key::Apostrophe);
   tolua_constant(tolua_S,"Grave",CEGUI::Key::Grave);
   tolua_constant(tolua_S,"LeftShift",CEGUI::Key::LeftShift);
   tolua_constant(tolua_S,"Backslash",CEGUI::Key::Backslash);
   tolua_constant(tolua_S,"Z",CEGUI::Key::Z);
   tolua_constant(tolua_S,"X",CEGUI::Key::X);
   tolua_constant(tolua_S,"C",CEGUI::Key::C);
   tolua_constant(tolua_S,"V",CEGUI::Key::V);
   tolua_constant(tolua_S,"B",CEGUI::Key::B);
   tolua_constant(tolua_S,"N",CEGUI::Key::N);
   tolua_constant(tolua_S,"M",CEGUI::Key::M);
   tolua_constant(tolua_S,"Comma",CEGUI::Key::Comma);
   tolua_constant(tolua_S,"Period",CEGUI::Key::Period);
   tolua_constant(tolua_S,"Slash",CEGUI::Key::Slash);
   tolua_constant(tolua_S,"RightShift",CEGUI::Key::RightShift);
   tolua_constant(tolua_S,"Multiply",CEGUI::Key::Multiply);
   tolua_constant(tolua_S,"LeftAlt",CEGUI::Key::LeftAlt);
   tolua_constant(tolua_S,"Space",CEGUI::Key::Space);
   tolua_constant(tolua_S,"Capital",CEGUI::Key::Capital);
   tolua_constant(tolua_S,"F1",CEGUI::Key::F1);
   tolua_constant(tolua_S,"F2",CEGUI::Key::F2);
   tolua_constant(tolua_S,"F3",CEGUI::Key::F3);
   tolua_constant(tolua_S,"F4",CEGUI::Key::F4);
   tolua_constant(tolua_S,"F5",CEGUI::Key::F5);
   tolua_constant(tolua_S,"F6",CEGUI::Key::F6);
   tolua_constant(tolua_S,"F7",CEGUI::Key::F7);
   tolua_constant(tolua_S,"F8",CEGUI::Key::F8);
   tolua_constant(tolua_S,"F9",CEGUI::Key::F9);
   tolua_constant(tolua_S,"F10",CEGUI::Key::F10);
   tolua_constant(tolua_S,"NumLock",CEGUI::Key::NumLock);
   tolua_constant(tolua_S,"ScrollLock",CEGUI::Key::ScrollLock);
   tolua_constant(tolua_S,"Numpad7",CEGUI::Key::Numpad7);
   tolua_constant(tolua_S,"Numpad8",CEGUI::Key::Numpad8);
   tolua_constant(tolua_S,"Numpad9",CEGUI::Key::Numpad9);
   tolua_constant(tolua_S,"Subtract",CEGUI::Key::Subtract);
   tolua_constant(tolua_S,"Numpad4",CEGUI::Key::Numpad4);
   tolua_constant(tolua_S,"Numpad5",CEGUI::Key::Numpad5);
   tolua_constant(tolua_S,"Numpad6",CEGUI::Key::Numpad6);
   tolua_constant(tolua_S,"Add",CEGUI::Key::Add);
   tolua_constant(tolua_S,"Numpad1",CEGUI::Key::Numpad1);
   tolua_constant(tolua_S,"Numpad2",CEGUI::Key::Numpad2);
   tolua_constant(tolua_S,"Numpad3",CEGUI::Key::Numpad3);
   tolua_constant(tolua_S,"Numpad0",CEGUI::Key::Numpad0);
   tolua_constant(tolua_S,"Decimal",CEGUI::Key::Decimal);
   tolua_constant(tolua_S,"OEM_102",CEGUI::Key::OEM_102);
   tolua_constant(tolua_S,"F11",CEGUI::Key::F11);
   tolua_constant(tolua_S,"F12",CEGUI::Key::F12);
   tolua_constant(tolua_S,"F13",CEGUI::Key::F13);
   tolua_constant(tolua_S,"F14",CEGUI::Key::F14);
   tolua_constant(tolua_S,"F15",CEGUI::Key::F15);
   tolua_constant(tolua_S,"Kana",CEGUI::Key::Kana);
   tolua_constant(tolua_S,"ABNT_C1",CEGUI::Key::ABNT_C1);
   tolua_constant(tolua_S,"Convert",CEGUI::Key::Convert);
   tolua_constant(tolua_S,"NoConvert",CEGUI::Key::NoConvert);
   tolua_constant(tolua_S,"Yen",CEGUI::Key::Yen);
   tolua_constant(tolua_S,"ABNT_C2",CEGUI::Key::ABNT_C2);
   tolua_constant(tolua_S,"NumpadEquals",CEGUI::Key::NumpadEquals);
   tolua_constant(tolua_S,"PrevTrack",CEGUI::Key::PrevTrack);
   tolua_constant(tolua_S,"At",CEGUI::Key::At);
   tolua_constant(tolua_S,"Colon",CEGUI::Key::Colon);
   tolua_constant(tolua_S,"Underline",CEGUI::Key::Underline);
   tolua_constant(tolua_S,"Kanji",CEGUI::Key::Kanji);
   tolua_constant(tolua_S,"Stop",CEGUI::Key::Stop);
   tolua_constant(tolua_S,"AX",CEGUI::Key::AX);
   tolua_constant(tolua_S,"Unlabeled",CEGUI::Key::Unlabeled);
   tolua_constant(tolua_S,"NextTrack",CEGUI::Key::NextTrack);
   tolua_constant(tolua_S,"NumpadEnter",CEGUI::Key::NumpadEnter);
   tolua_constant(tolua_S,"RightControl",CEGUI::Key::RightControl);
   tolua_constant(tolua_S,"Mute",CEGUI::Key::Mute);
   tolua_constant(tolua_S,"Calculator",CEGUI::Key::Calculator);
   tolua_constant(tolua_S,"PlayPause",CEGUI::Key::PlayPause);
   tolua_constant(tolua_S,"MediaStop",CEGUI::Key::MediaStop);
   tolua_constant(tolua_S,"VolumeDown",CEGUI::Key::VolumeDown);
   tolua_constant(tolua_S,"VolumeUp",CEGUI::Key::VolumeUp);
   tolua_constant(tolua_S,"WebHome",CEGUI::Key::WebHome);
   tolua_constant(tolua_S,"NumpadComma",CEGUI::Key::NumpadComma);
   tolua_constant(tolua_S,"Divide",CEGUI::Key::Divide);
   tolua_constant(tolua_S,"SysRq",CEGUI::Key::SysRq);
   tolua_constant(tolua_S,"RightAlt",CEGUI::Key::RightAlt);
   tolua_constant(tolua_S,"Pause",CEGUI::Key::Pause);
   tolua_constant(tolua_S,"Home",CEGUI::Key::Home);
   tolua_constant(tolua_S,"ArrowUp",CEGUI::Key::ArrowUp);
   tolua_constant(tolua_S,"PageUp",CEGUI::Key::PageUp);
   tolua_constant(tolua_S,"ArrowLeft",CEGUI::Key::ArrowLeft);
   tolua_constant(tolua_S,"ArrowRight",CEGUI::Key::ArrowRight);
   tolua_constant(tolua_S,"End",CEGUI::Key::End);
   tolua_constant(tolua_S,"ArrowDown",CEGUI::Key::ArrowDown);
   tolua_constant(tolua_S,"PageDown",CEGUI::Key::PageDown);
   tolua_constant(tolua_S,"Insert",CEGUI::Key::Insert);
   tolua_constant(tolua_S,"Delete",CEGUI::Key::Delete);
   tolua_constant(tolua_S,"LeftWindows",CEGUI::Key::LeftWindows);
   tolua_constant(tolua_S,"RightWindows",CEGUI::Key::RightWindows);
   tolua_constant(tolua_S,"AppMenu",CEGUI::Key::AppMenu);
   tolua_constant(tolua_S,"Power",CEGUI::Key::Power);
   tolua_constant(tolua_S,"Sleep",CEGUI::Key::Sleep);
   tolua_constant(tolua_S,"Wake",CEGUI::Key::Wake);
   tolua_constant(tolua_S,"WebSearch",CEGUI::Key::WebSearch);
   tolua_constant(tolua_S,"WebFavorites",CEGUI::Key::WebFavorites);
   tolua_constant(tolua_S,"WebRefresh",CEGUI::Key::WebRefresh);
   tolua_constant(tolua_S,"WebStop",CEGUI::Key::WebStop);
   tolua_constant(tolua_S,"WebForward",CEGUI::Key::WebForward);
   tolua_constant(tolua_S,"WebBack",CEGUI::Key::WebBack);
   tolua_constant(tolua_S,"MyComputer",CEGUI::Key::MyComputer);
   tolua_constant(tolua_S,"Mail",CEGUI::Key::Mail);
   tolua_constant(tolua_S,"MediaSelect",CEGUI::Key::MediaSelect);
  tolua_endmodule(tolua_S);
  tolua_constant(tolua_S,"LeftMouse",CEGUI::LeftMouse);
  tolua_constant(tolua_S,"RightMouse",CEGUI::RightMouse);
  tolua_constant(tolua_S,"Shift",CEGUI::Shift);
  tolua_constant(tolua_S,"Control",CEGUI::Control);
  tolua_constant(tolua_S,"MiddleMouse",CEGUI::MiddleMouse);
  tolua_constant(tolua_S,"X1Mouse",CEGUI::X1Mouse);
  tolua_constant(tolua_S,"X2Mouse",CEGUI::X2Mouse);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"EventArgs","CEGUI::EventArgs","",tolua_collect_CEGUI__EventArgs);
  #else
  tolua_cclass(tolua_S,"EventArgs","CEGUI::EventArgs","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"EventArgs");
   tolua_variable(tolua_S,"handled",tolua_get_CEGUI__EventArgs_unsigned_handled,tolua_set_CEGUI__EventArgs_unsigned_handled);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_EventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_EventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_EventArgs_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"MouseCursorEventArgs","CEGUI::MouseCursorEventArgs","CEGUI::EventArgs",tolua_collect_CEGUI__MouseCursorEventArgs);
  #else
  tolua_cclass(tolua_S,"MouseCursorEventArgs","CEGUI::MouseCursorEventArgs","CEGUI::EventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"MouseCursorEventArgs");
   tolua_variable(tolua_S,"mouseCursor",tolua_get_CEGUI__MouseCursorEventArgs_mouseCursor_ptr,tolua_set_CEGUI__MouseCursorEventArgs_mouseCursor_ptr);
   tolua_variable(tolua_S,"image",tolua_get_CEGUI__MouseCursorEventArgs_image_ptr,NULL);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_MouseCursorEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_MouseCursorEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_MouseCursorEventArgs_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"WindowEventArgs","CEGUI::WindowEventArgs","CEGUI::EventArgs",tolua_collect_CEGUI__WindowEventArgs);
  #else
  tolua_cclass(tolua_S,"WindowEventArgs","CEGUI::WindowEventArgs","CEGUI::EventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"WindowEventArgs");
   tolua_variable(tolua_S,"window",tolua_get_CEGUI__WindowEventArgs_window_ptr,tolua_set_CEGUI__WindowEventArgs_window_ptr);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_WindowEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_WindowEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_WindowEventArgs_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"ActivationEventArgs","CEGUI::ActivationEventArgs","CEGUI::WindowEventArgs",tolua_collect_CEGUI__ActivationEventArgs);
  #else
  tolua_cclass(tolua_S,"ActivationEventArgs","CEGUI::ActivationEventArgs","CEGUI::WindowEventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ActivationEventArgs");
   tolua_variable(tolua_S,"otherWindow",tolua_get_CEGUI__ActivationEventArgs_otherWindow_ptr,tolua_set_CEGUI__ActivationEventArgs_otherWindow_ptr);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_ActivationEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_ActivationEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_ActivationEventArgs_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"HeaderSequenceEventArgs","CEGUI::HeaderSequenceEventArgs","CEGUI::WindowEventArgs",tolua_collect_CEGUI__HeaderSequenceEventArgs);
  #else
  tolua_cclass(tolua_S,"HeaderSequenceEventArgs","CEGUI::HeaderSequenceEventArgs","CEGUI::WindowEventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"HeaderSequenceEventArgs");
   tolua_variable(tolua_S,"oldIdx",tolua_get_CEGUI__HeaderSequenceEventArgs_unsigned_oldIdx,tolua_set_CEGUI__HeaderSequenceEventArgs_unsigned_oldIdx);
   tolua_variable(tolua_S,"newIdx",tolua_get_CEGUI__HeaderSequenceEventArgs_unsigned_newIdx,tolua_set_CEGUI__HeaderSequenceEventArgs_unsigned_newIdx);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_HeaderSequenceEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_HeaderSequenceEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_HeaderSequenceEventArgs_new00_local);
  tolua_endmodule(tolua_S);
  tolua_constant(tolua_S,"LeftButton",CEGUI::LeftButton);
  tolua_constant(tolua_S,"RightButton",CEGUI::RightButton);
  tolua_constant(tolua_S,"MiddleButton",CEGUI::MiddleButton);
  tolua_constant(tolua_S,"X1Button",CEGUI::X1Button);
  tolua_constant(tolua_S,"X2Button",CEGUI::X2Button);
  tolua_constant(tolua_S,"MouseButtonCount",CEGUI::MouseButtonCount);
  tolua_constant(tolua_S,"NoButton",CEGUI::NoButton);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"MouseEventArgs","CEGUI::MouseEventArgs","CEGUI::WindowEventArgs",tolua_collect_CEGUI__MouseEventArgs);
  #else
  tolua_cclass(tolua_S,"MouseEventArgs","CEGUI::MouseEventArgs","CEGUI::WindowEventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"MouseEventArgs");
   tolua_variable(tolua_S,"position",tolua_get_CEGUI__MouseEventArgs_position,tolua_set_CEGUI__MouseEventArgs_position);
   tolua_variable(tolua_S,"moveDelta",tolua_get_CEGUI__MouseEventArgs_moveDelta,tolua_set_CEGUI__MouseEventArgs_moveDelta);
   tolua_variable(tolua_S,"button",tolua_get_CEGUI__MouseEventArgs_button,tolua_set_CEGUI__MouseEventArgs_button);
   tolua_variable(tolua_S,"sysKeys",tolua_get_CEGUI__MouseEventArgs_unsigned_sysKeys,tolua_set_CEGUI__MouseEventArgs_unsigned_sysKeys);
   tolua_variable(tolua_S,"wheelChange",tolua_get_CEGUI__MouseEventArgs_wheelChange,tolua_set_CEGUI__MouseEventArgs_wheelChange);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_MouseEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_MouseEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_MouseEventArgs_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"KeyEventArgs","CEGUI::KeyEventArgs","CEGUI::WindowEventArgs",tolua_collect_CEGUI__KeyEventArgs);
  #else
  tolua_cclass(tolua_S,"KeyEventArgs","CEGUI::KeyEventArgs","CEGUI::WindowEventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"KeyEventArgs");
   tolua_variable(tolua_S,"codepoint",tolua_get_CEGUI__KeyEventArgs_unsigned_codepoint,tolua_set_CEGUI__KeyEventArgs_unsigned_codepoint);
   tolua_variable(tolua_S,"scancode",tolua_get_CEGUI__KeyEventArgs_scancode,tolua_set_CEGUI__KeyEventArgs_scancode);
   tolua_variable(tolua_S,"sysKeys",tolua_get_CEGUI__KeyEventArgs_unsigned_sysKeys,tolua_set_CEGUI__KeyEventArgs_unsigned_sysKeys);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_KeyEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_KeyEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_KeyEventArgs_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"DragDropEventArgs","CEGUI::DragDropEventArgs","CEGUI::WindowEventArgs",tolua_collect_CEGUI__DragDropEventArgs);
  #else
  tolua_cclass(tolua_S,"DragDropEventArgs","CEGUI::DragDropEventArgs","CEGUI::WindowEventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"DragDropEventArgs");
   tolua_variable(tolua_S,"dragDropItem",tolua_get_CEGUI__DragDropEventArgs_dragDropItem_ptr,tolua_set_CEGUI__DragDropEventArgs_dragDropItem_ptr);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_DragDropEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_DragDropEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_DragDropEventArgs_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"TreeEventArgs","CEGUI::TreeEventArgs","CEGUI::WindowEventArgs",tolua_collect_CEGUI__TreeEventArgs);
  #else
  tolua_cclass(tolua_S,"TreeEventArgs","CEGUI::TreeEventArgs","CEGUI::WindowEventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"TreeEventArgs");
   tolua_variable(tolua_S,"treeItem",tolua_get_CEGUI__TreeEventArgs_treeItem_ptr,tolua_set_CEGUI__TreeEventArgs_treeItem_ptr);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_TreeEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_TreeEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_TreeEventArgs_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"RenderQueueEventArgs","CEGUI::RenderQueueEventArgs","CEGUI::EventArgs",tolua_collect_CEGUI__RenderQueueEventArgs);
  #else
  tolua_cclass(tolua_S,"RenderQueueEventArgs","CEGUI::RenderQueueEventArgs","CEGUI::EventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"RenderQueueEventArgs");
   tolua_variable(tolua_S,"queueID",tolua_get_CEGUI__RenderQueueEventArgs_queueID,tolua_set_CEGUI__RenderQueueEventArgs_queueID);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_RenderQueueEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_RenderQueueEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_RenderQueueEventArgs_new00_local);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Event","CEGUI::Event","",NULL);
  tolua_beginmodule(tolua_S,"Event");
   tolua_function(tolua_S,"getName",tolua_CEGUI_CEGUI_Event_getName00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"EventConnection","CEGUI::EventConnection","",tolua_collect_CEGUI__EventConnection);
  #else
  tolua_cclass(tolua_S,"EventConnection","CEGUI::EventConnection","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"EventConnection");
   tolua_function(tolua_S,"connected",tolua_CEGUI_CEGUI_EventConnection_connected00);
   tolua_function(tolua_S,"disconnect",tolua_CEGUI_CEGUI_EventConnection_disconnect00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"EventSet","CEGUI::EventSet","",NULL);
  tolua_beginmodule(tolua_S,"EventSet");
   tolua_function(tolua_S,"addEvent",tolua_CEGUI_CEGUI_EventSet_addEvent00);
   tolua_function(tolua_S,"removeEvent",tolua_CEGUI_CEGUI_EventSet_removeEvent00);
   tolua_function(tolua_S,"removeAllEvents",tolua_CEGUI_CEGUI_EventSet_removeAllEvents00);
   tolua_function(tolua_S,"isEventPresent",tolua_CEGUI_CEGUI_EventSet_isEventPresent00);
   tolua_function(tolua_S,"subscribeEvent",tolua_CEGUI_CEGUI_EventSet_subscribeEvent00);
   tolua_function(tolua_S,"subscribeEvent",tolua_CEGUI_CEGUI_EventSet_subscribeEvent01);
   tolua_function(tolua_S,"fireEvent",tolua_CEGUI_CEGUI_EventSet_fireEvent00);
   tolua_function(tolua_S,"isMuted",tolua_CEGUI_CEGUI_EventSet_isMuted00);
   tolua_function(tolua_S,"setMutedState",tolua_CEGUI_CEGUI_EventSet_setMutedState00);
   tolua_function(tolua_S,"getEventIterator",tolua_CEGUI_CEGUI_EventSet_getEventIterator00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"GlobalEventSet","CEGUI::GlobalEventSet","CEGUI::EventSet",NULL);
  tolua_beginmodule(tolua_S,"GlobalEventSet");
   tolua_function(tolua_S,"getSingleton",tolua_CEGUI_CEGUI_GlobalEventSet_getSingleton00);
  tolua_endmodule(tolua_S);
  tolua_constant(tolua_S,"BlankMouseCursor",CEGUI::BlankMouseCursor);
  tolua_constant(tolua_S,"DefaultMouseCursor",CEGUI::DefaultMouseCursor);
  tolua_cclass(tolua_S,"MouseCursor","CEGUI::MouseCursor","CEGUI::EventSet",NULL);
  tolua_beginmodule(tolua_S,"MouseCursor");
   tolua_function(tolua_S,"getSingleton",tolua_CEGUI_CEGUI_MouseCursor_getSingleton00);
   tolua_function(tolua_S,"setImage",tolua_CEGUI_CEGUI_MouseCursor_setImage00);
   tolua_function(tolua_S,"setImage",tolua_CEGUI_CEGUI_MouseCursor_setImage01);
   tolua_function(tolua_S,"getImage",tolua_CEGUI_CEGUI_MouseCursor_getImage00);
   tolua_function(tolua_S,"setPosition",tolua_CEGUI_CEGUI_MouseCursor_setPosition00);
   tolua_function(tolua_S,"offsetPosition",tolua_CEGUI_CEGUI_MouseCursor_offsetPosition00);
   tolua_function(tolua_S,"setConstraintArea",tolua_CEGUI_CEGUI_MouseCursor_setConstraintArea00);
   tolua_function(tolua_S,"getPosition",tolua_CEGUI_CEGUI_MouseCursor_getPosition00);
   tolua_function(tolua_S,"getConstraintArea",tolua_CEGUI_CEGUI_MouseCursor_getConstraintArea00);
   tolua_function(tolua_S,"getDisplayIndependantPosition",tolua_CEGUI_CEGUI_MouseCursor_getDisplayIndependantPosition00);
   tolua_function(tolua_S,"setUnifiedConstraintArea",tolua_CEGUI_CEGUI_MouseCursor_setUnifiedConstraintArea00);
   tolua_function(tolua_S,"getUnifiedConstraintArea",tolua_CEGUI_CEGUI_MouseCursor_getUnifiedConstraintArea00);
   tolua_function(tolua_S,"hide",tolua_CEGUI_CEGUI_MouseCursor_hide00);
   tolua_function(tolua_S,"show",tolua_CEGUI_CEGUI_MouseCursor_show00);
   tolua_function(tolua_S,"setVisible",tolua_CEGUI_CEGUI_MouseCursor_setVisible00);
   tolua_function(tolua_S,"isVisible",tolua_CEGUI_CEGUI_MouseCursor_isVisible00);
   tolua_function(tolua_S,"setExplicitRenderSize",tolua_CEGUI_CEGUI_MouseCursor_setExplicitRenderSize00);
   tolua_function(tolua_S,"getExplicitRenderSize",tolua_CEGUI_CEGUI_MouseCursor_getExplicitRenderSize00);
   tolua_function(tolua_S,"getEventIterator",tolua_CEGUI_CEGUI_MouseCursor_getEventIterator00);
  tolua_endmodule(tolua_S);
  tolua_constant(tolua_S,"VA_TOP",CEGUI::VA_TOP);
  tolua_constant(tolua_S,"VA_CENTRE",CEGUI::VA_CENTRE);
  tolua_constant(tolua_S,"VA_BOTTOM",CEGUI::VA_BOTTOM);
  tolua_constant(tolua_S,"HA_LEFT",CEGUI::HA_LEFT);
  tolua_constant(tolua_S,"HA_CENTRE",CEGUI::HA_CENTRE);
  tolua_constant(tolua_S,"HA_RIGHT",CEGUI::HA_RIGHT);
  tolua_constant(tolua_S,"WUM_ALWAYS",CEGUI::WUM_ALWAYS);
  tolua_constant(tolua_S,"WUM_NEVER",CEGUI::WUM_NEVER);
  tolua_constant(tolua_S,"WUM_VISIBLE",CEGUI::WUM_VISIBLE);
  tolua_cclass(tolua_S,"Window","CEGUI::Window","",NULL);
  tolua_beginmodule(tolua_S,"Window");
   tolua_function(tolua_S,"getType",tolua_CEGUI_CEGUI_Window_getType00);
   tolua_function(tolua_S,"getName",tolua_CEGUI_CEGUI_Window_getName00);
   tolua_function(tolua_S,"rename",tolua_CEGUI_CEGUI_Window_rename00);
   tolua_function(tolua_S,"isAutoWindow",tolua_CEGUI_CEGUI_Window_isAutoWindow00);
   tolua_function(tolua_S,"isDestroyedByParent",tolua_CEGUI_CEGUI_Window_isDestroyedByParent00);
   tolua_function(tolua_S,"isAlwaysOnTop",tolua_CEGUI_CEGUI_Window_isAlwaysOnTop00);
   tolua_function(tolua_S,"isDisabled",tolua_CEGUI_CEGUI_Window_isDisabled00);
   tolua_function(tolua_S,"isVisible",tolua_CEGUI_CEGUI_Window_isVisible00);
   tolua_function(tolua_S,"isActive",tolua_CEGUI_CEGUI_Window_isActive00);
   tolua_function(tolua_S,"isClippedByParent",tolua_CEGUI_CEGUI_Window_isClippedByParent00);
   tolua_function(tolua_S,"setDestroyedByParent",tolua_CEGUI_CEGUI_Window_setDestroyedByParent00);
   tolua_function(tolua_S,"setAlwaysOnTop",tolua_CEGUI_CEGUI_Window_setAlwaysOnTop00);
   tolua_function(tolua_S,"setEnabled",tolua_CEGUI_CEGUI_Window_setEnabled00);
   tolua_function(tolua_S,"enable",tolua_CEGUI_CEGUI_Window_enable00);
   tolua_function(tolua_S,"disable",tolua_CEGUI_CEGUI_Window_disable00);
   tolua_function(tolua_S,"setVisible",tolua_CEGUI_CEGUI_Window_setVisible00);
   tolua_function(tolua_S,"show",tolua_CEGUI_CEGUI_Window_show00);
   tolua_function(tolua_S,"hide",tolua_CEGUI_CEGUI_Window_hide00);
   tolua_function(tolua_S,"activate",tolua_CEGUI_CEGUI_Window_activate00);
   tolua_function(tolua_S,"deactivate",tolua_CEGUI_CEGUI_Window_deactivate00);
   tolua_function(tolua_S,"setClippedByParent",tolua_CEGUI_CEGUI_Window_setClippedByParent00);
   tolua_function(tolua_S,"getID",tolua_CEGUI_CEGUI_Window_getID00);
   tolua_function(tolua_S,"setID",tolua_CEGUI_CEGUI_Window_setID00);
   tolua_function(tolua_S,"getChildCount",tolua_CEGUI_CEGUI_Window_getChildCount00);
   tolua_function(tolua_S,"isChild",tolua_CEGUI_CEGUI_Window_isChild00);
   tolua_function(tolua_S,"isChild",tolua_CEGUI_CEGUI_Window_isChild01);
   tolua_function(tolua_S,"isChild",tolua_CEGUI_CEGUI_Window_isChild02);
   tolua_function(tolua_S,"isChildRecursive",tolua_CEGUI_CEGUI_Window_isChildRecursive00);
   tolua_function(tolua_S,"addChildWindow",tolua_CEGUI_CEGUI_Window_addChildWindow00);
   tolua_function(tolua_S,"addChildWindow",tolua_CEGUI_CEGUI_Window_addChildWindow01);
   tolua_function(tolua_S,"removeChildWindow",tolua_CEGUI_CEGUI_Window_removeChildWindow00);
   tolua_function(tolua_S,"removeChildWindow",tolua_CEGUI_CEGUI_Window_removeChildWindow01);
   tolua_function(tolua_S,"removeChildWindow",tolua_CEGUI_CEGUI_Window_removeChildWindow02);
   tolua_function(tolua_S,"getChild",tolua_CEGUI_CEGUI_Window_getChild00);
   tolua_function(tolua_S,"getChild",tolua_CEGUI_CEGUI_Window_getChild01);
   tolua_function(tolua_S,"getChildRecursive",tolua_CEGUI_CEGUI_Window_getChildRecursive00);
   tolua_function(tolua_S,"getChildRecursive",tolua_CEGUI_CEGUI_Window_getChildRecursive01);
   tolua_function(tolua_S,"getChildAtIdx",tolua_CEGUI_CEGUI_Window_getChildAtIdx00);
   tolua_function(tolua_S,"getChildAtPosition",tolua_CEGUI_CEGUI_Window_getChildAtPosition00);
   tolua_function(tolua_S,"getTargetChildAtPosition",tolua_CEGUI_CEGUI_Window_getTargetChildAtPosition00);
   tolua_function(tolua_S,"getActiveChild",tolua_CEGUI_CEGUI_Window_getActiveChild00);
   tolua_function(tolua_S,"getActiveSibling",tolua_CEGUI_CEGUI_Window_getActiveSibling00);
   tolua_function(tolua_S,"getParent",tolua_CEGUI_CEGUI_Window_getParent00);
   tolua_function(tolua_S,"getRootWindow",tolua_CEGUI_CEGUI_Window_getRootWindow00);
   tolua_function(tolua_S,"getRootWindow",tolua_CEGUI_CEGUI_Window_getRootWindow01);
   tolua_function(tolua_S,"isAncestor",tolua_CEGUI_CEGUI_Window_isAncestor00);
   tolua_function(tolua_S,"isAncestor",tolua_CEGUI_CEGUI_Window_isAncestor01);
   tolua_function(tolua_S,"isAncestor",tolua_CEGUI_CEGUI_Window_isAncestor02);
   tolua_function(tolua_S,"setFont",tolua_CEGUI_CEGUI_Window_setFont00);
   tolua_function(tolua_S,"setFont",tolua_CEGUI_CEGUI_Window_setFont01);
   tolua_function(tolua_S,"getFont",tolua_CEGUI_CEGUI_Window_getFont00);
   tolua_function(tolua_S,"setText",tolua_CEGUI_CEGUI_Window_setText00);
   tolua_function(tolua_S,"insertText",tolua_CEGUI_CEGUI_Window_insertText00);
   tolua_function(tolua_S,"appendText",tolua_CEGUI_CEGUI_Window_appendText00);
   tolua_function(tolua_S,"getText",tolua_CEGUI_CEGUI_Window_getText00);
   tolua_function(tolua_S,"inheritsAlpha",tolua_CEGUI_CEGUI_Window_inheritsAlpha00);
   tolua_function(tolua_S,"getAlpha",tolua_CEGUI_CEGUI_Window_getAlpha00);
   tolua_function(tolua_S,"getEffectiveAlpha",tolua_CEGUI_CEGUI_Window_getEffectiveAlpha00);
   tolua_function(tolua_S,"setAlpha",tolua_CEGUI_CEGUI_Window_setAlpha00);
   tolua_function(tolua_S,"setInheritsAlpha",tolua_CEGUI_CEGUI_Window_setInheritsAlpha00);
   tolua_function(tolua_S,"invalidate",tolua_CEGUI_CEGUI_Window_invalidate00);
   tolua_function(tolua_S,"isZOrderingEnabled",tolua_CEGUI_CEGUI_Window_isZOrderingEnabled00);
   tolua_function(tolua_S,"setZOrderingEnabled",tolua_CEGUI_CEGUI_Window_setZOrderingEnabled00);
   tolua_function(tolua_S,"getUnclippedOuterRect",tolua_CEGUI_CEGUI_Window_getUnclippedOuterRect00);
   tolua_function(tolua_S,"getUnclippedInnerRect",tolua_CEGUI_CEGUI_Window_getUnclippedInnerRect00);
   tolua_function(tolua_S,"getUnclippedRect",tolua_CEGUI_CEGUI_Window_getUnclippedRect00);
   tolua_function(tolua_S,"getOuterRectClipper",tolua_CEGUI_CEGUI_Window_getOuterRectClipper00);
   tolua_function(tolua_S,"getInnerRectClipper",tolua_CEGUI_CEGUI_Window_getInnerRectClipper00);
   tolua_function(tolua_S,"getClipRect",tolua_CEGUI_CEGUI_Window_getClipRect00);
   tolua_function(tolua_S,"getHitTestRect",tolua_CEGUI_CEGUI_Window_getHitTestRect00);
   tolua_function(tolua_S,"getPixelSize",tolua_CEGUI_CEGUI_Window_getPixelSize00);
   tolua_function(tolua_S,"getParentPixelSize",tolua_CEGUI_CEGUI_Window_getParentPixelSize00);
   tolua_function(tolua_S,"getParentPixelWidth",tolua_CEGUI_CEGUI_Window_getParentPixelWidth00);
   tolua_function(tolua_S,"getParentPixelHeight",tolua_CEGUI_CEGUI_Window_getParentPixelHeight00);
   tolua_function(tolua_S,"getCaptureWindow",tolua_CEGUI_CEGUI_Window_getCaptureWindow00);
   tolua_function(tolua_S,"setRestoreCapture",tolua_CEGUI_CEGUI_Window_setRestoreCapture00);
   tolua_function(tolua_S,"restoresOldCapture",tolua_CEGUI_CEGUI_Window_restoresOldCapture00);
   tolua_function(tolua_S,"distributesCapturedInputs",tolua_CEGUI_CEGUI_Window_distributesCapturedInputs00);
   tolua_function(tolua_S,"setDistributesCapturedInputs",tolua_CEGUI_CEGUI_Window_setDistributesCapturedInputs00);
   tolua_function(tolua_S,"captureInput",tolua_CEGUI_CEGUI_Window_captureInput00);
   tolua_function(tolua_S,"releaseInput",tolua_CEGUI_CEGUI_Window_releaseInput00);
   tolua_function(tolua_S,"isCapturedByThis",tolua_CEGUI_CEGUI_Window_isCapturedByThis00);
   tolua_function(tolua_S,"isCapturedByAncestor",tolua_CEGUI_CEGUI_Window_isCapturedByAncestor00);
   tolua_function(tolua_S,"isCapturedByChild",tolua_CEGUI_CEGUI_Window_isCapturedByChild00);
   tolua_function(tolua_S,"isHit",tolua_CEGUI_CEGUI_Window_isHit00);
   tolua_function(tolua_S,"isRiseOnClickEnabled",tolua_CEGUI_CEGUI_Window_isRiseOnClickEnabled00);
   tolua_function(tolua_S,"setRiseOnClickEnabled",tolua_CEGUI_CEGUI_Window_setRiseOnClickEnabled00);
   tolua_function(tolua_S,"getMouseCursor",tolua_CEGUI_CEGUI_Window_getMouseCursor00);
   tolua_function(tolua_S,"setMouseCursor",tolua_CEGUI_CEGUI_Window_setMouseCursor00);
   tolua_function(tolua_S,"setMouseCursor",tolua_CEGUI_CEGUI_Window_setMouseCursor01);
   tolua_function(tolua_S,"setMouseCursor",tolua_CEGUI_CEGUI_Window_setMouseCursor02);
   tolua_function(tolua_S,"moveToFront",tolua_CEGUI_CEGUI_Window_moveToFront00);
   tolua_function(tolua_S,"moveToBack",tolua_CEGUI_CEGUI_Window_moveToBack00);
   tolua_function(tolua_S,"moveInFront",tolua_CEGUI_CEGUI_Window_moveInFront00);
   tolua_function(tolua_S,"moveBehind",tolua_CEGUI_CEGUI_Window_moveBehind00);
   tolua_function(tolua_S,"wantsMultiClickEvents",tolua_CEGUI_CEGUI_Window_wantsMultiClickEvents00);
   tolua_function(tolua_S,"isMouseAutoRepeatEnabled",tolua_CEGUI_CEGUI_Window_isMouseAutoRepeatEnabled00);
   tolua_function(tolua_S,"getAutoRepeatDelay",tolua_CEGUI_CEGUI_Window_getAutoRepeatDelay00);
   tolua_function(tolua_S,"getAutoRepeatRate",tolua_CEGUI_CEGUI_Window_getAutoRepeatRate00);
   tolua_function(tolua_S,"setWantsMultiClickEvents",tolua_CEGUI_CEGUI_Window_setWantsMultiClickEvents00);
   tolua_function(tolua_S,"setMouseAutoRepeatEnabled",tolua_CEGUI_CEGUI_Window_setMouseAutoRepeatEnabled00);
   tolua_function(tolua_S,"setAutoRepeatDelay",tolua_CEGUI_CEGUI_Window_setAutoRepeatDelay00);
   tolua_function(tolua_S,"setAutoRepeatRate",tolua_CEGUI_CEGUI_Window_setAutoRepeatRate00);
   tolua_function(tolua_S,"isUsingDefaultTooltip",tolua_CEGUI_CEGUI_Window_isUsingDefaultTooltip00);
   tolua_function(tolua_S,"getTooltip",tolua_CEGUI_CEGUI_Window_getTooltip00);
   tolua_function(tolua_S,"getTooltipType",tolua_CEGUI_CEGUI_Window_getTooltipType00);
   tolua_function(tolua_S,"getTooltipText",tolua_CEGUI_CEGUI_Window_getTooltipText00);
   tolua_function(tolua_S,"inheritsTooltipText",tolua_CEGUI_CEGUI_Window_inheritsTooltipText00);
   tolua_function(tolua_S,"setTooltip",tolua_CEGUI_CEGUI_Window_setTooltip00);
   tolua_function(tolua_S,"setTooltipType",tolua_CEGUI_CEGUI_Window_setTooltipType00);
   tolua_function(tolua_S,"setTooltipText",tolua_CEGUI_CEGUI_Window_setTooltipText00);
   tolua_function(tolua_S,"setInheritsTooltipText",tolua_CEGUI_CEGUI_Window_setInheritsTooltipText00);
   tolua_function(tolua_S,"testClassName",tolua_CEGUI_CEGUI_Window_testClassName00);
   tolua_function(tolua_S,"isDragDropTarget",tolua_CEGUI_CEGUI_Window_isDragDropTarget00);
   tolua_function(tolua_S,"setDragDropTarget",tolua_CEGUI_CEGUI_Window_setDragDropTarget00);
   tolua_function(tolua_S,"notifyDragDropItemEnters",tolua_CEGUI_CEGUI_Window_notifyDragDropItemEnters00);
   tolua_function(tolua_S,"notifyDragDropItemLeaves",tolua_CEGUI_CEGUI_Window_notifyDragDropItemLeaves00);
   tolua_function(tolua_S,"notifyDragDropItemDropped",tolua_CEGUI_CEGUI_Window_notifyDragDropItemDropped00);
   tolua_function(tolua_S,"getVerticalAlignment",tolua_CEGUI_CEGUI_Window_getVerticalAlignment00);
   tolua_function(tolua_S,"getHorizontalAlignment",tolua_CEGUI_CEGUI_Window_getHorizontalAlignment00);
   tolua_function(tolua_S,"setVerticalAlignment",tolua_CEGUI_CEGUI_Window_setVerticalAlignment00);
   tolua_function(tolua_S,"setHorizontalAlignment",tolua_CEGUI_CEGUI_Window_setHorizontalAlignment00);
   tolua_function(tolua_S,"getLookNFeel",tolua_CEGUI_CEGUI_Window_getLookNFeel00);
   tolua_function(tolua_S,"setLookNFeel",tolua_CEGUI_CEGUI_Window_setLookNFeel00);
   tolua_function(tolua_S,"setWindowRenderer",tolua_CEGUI_CEGUI_Window_setWindowRenderer00);
   tolua_function(tolua_S,"getWindowRendererName",tolua_CEGUI_CEGUI_Window_getWindowRendererName00);
   tolua_function(tolua_S,"getModalState",tolua_CEGUI_CEGUI_Window_getModalState00);
   tolua_function(tolua_S,"setModalState",tolua_CEGUI_CEGUI_Window_setModalState00);
   tolua_function(tolua_S,"getUserString",tolua_CEGUI_CEGUI_Window_getUserString00);
   tolua_function(tolua_S,"isUserStringDefined",tolua_CEGUI_CEGUI_Window_isUserStringDefined00);
   tolua_function(tolua_S,"setUserString",tolua_CEGUI_CEGUI_Window_setUserString00);
   tolua_function(tolua_S,"beginInitialisation",tolua_CEGUI_CEGUI_Window_beginInitialisation00);
   tolua_function(tolua_S,"endInitialisation",tolua_CEGUI_CEGUI_Window_endInitialisation00);
   tolua_function(tolua_S,"setArea",tolua_CEGUI_CEGUI_Window_setArea00);
   tolua_function(tolua_S,"setArea",tolua_CEGUI_CEGUI_Window_setArea01);
   tolua_function(tolua_S,"setArea",tolua_CEGUI_CEGUI_Window_setArea02);
   tolua_function(tolua_S,"setPosition",tolua_CEGUI_CEGUI_Window_setPosition00);
   tolua_function(tolua_S,"setXPosition",tolua_CEGUI_CEGUI_Window_setXPosition00);
   tolua_function(tolua_S,"setYPosition",tolua_CEGUI_CEGUI_Window_setYPosition00);
   tolua_function(tolua_S,"setSize",tolua_CEGUI_CEGUI_Window_setSize00);
   tolua_function(tolua_S,"setWidth",tolua_CEGUI_CEGUI_Window_setWidth00);
   tolua_function(tolua_S,"setHeight",tolua_CEGUI_CEGUI_Window_setHeight00);
   tolua_function(tolua_S,"setMaxSize",tolua_CEGUI_CEGUI_Window_setMaxSize00);
   tolua_function(tolua_S,"setMinSize",tolua_CEGUI_CEGUI_Window_setMinSize00);
   tolua_function(tolua_S,"getArea",tolua_CEGUI_CEGUI_Window_getArea00);
   tolua_function(tolua_S,"getPosition",tolua_CEGUI_CEGUI_Window_getPosition00);
   tolua_function(tolua_S,"getXPosition",tolua_CEGUI_CEGUI_Window_getXPosition00);
   tolua_function(tolua_S,"getYPosition",tolua_CEGUI_CEGUI_Window_getYPosition00);
   tolua_function(tolua_S,"getSize",tolua_CEGUI_CEGUI_Window_getSize00);
   tolua_function(tolua_S,"getWidth",tolua_CEGUI_CEGUI_Window_getWidth00);
   tolua_function(tolua_S,"getHeight",tolua_CEGUI_CEGUI_Window_getHeight00);
   tolua_function(tolua_S,"getMaxSize",tolua_CEGUI_CEGUI_Window_getMaxSize00);
   tolua_function(tolua_S,"getMinSize",tolua_CEGUI_CEGUI_Window_getMinSize00);
   tolua_function(tolua_S,"isMousePassThroughEnabled",tolua_CEGUI_CEGUI_Window_isMousePassThroughEnabled00);
   tolua_function(tolua_S,"setMousePassThroughEnabled",tolua_CEGUI_CEGUI_Window_setMousePassThroughEnabled00);
   tolua_function(tolua_S,"isWritingXMLAllowed",tolua_CEGUI_CEGUI_Window_isWritingXMLAllowed00);
   tolua_function(tolua_S,"setWritingXMLAllowed",tolua_CEGUI_CEGUI_Window_setWritingXMLAllowed00);
   tolua_function(tolua_S,"getRotation",tolua_CEGUI_CEGUI_Window_getRotation00);
   tolua_function(tolua_S,"setRotation",tolua_CEGUI_CEGUI_Window_setRotation00);
   tolua_function(tolua_S,"getTargetRenderingSurface",tolua_CEGUI_CEGUI_Window_getTargetRenderingSurface00);
   tolua_function(tolua_S,"getRenderingContext",tolua_CEGUI_CEGUI_Window_getRenderingContext00);
   tolua_function(tolua_S,"getRenderingSurface",tolua_CEGUI_CEGUI_Window_getRenderingSurface00);
   tolua_function(tolua_S,"setRenderingSurface",tolua_CEGUI_CEGUI_Window_setRenderingSurface00);
   tolua_function(tolua_S,"isUsingAutoRenderingSurface",tolua_CEGUI_CEGUI_Window_isUsingAutoRenderingSurface00);
   tolua_function(tolua_S,"setUsingAutoRenderingSurface",tolua_CEGUI_CEGUI_Window_setUsingAutoRenderingSurface00);
   tolua_function(tolua_S,"invalidateRenderingSurface",tolua_CEGUI_CEGUI_Window_invalidateRenderingSurface00);
   tolua_function(tolua_S,"isNonClientWindow",tolua_CEGUI_CEGUI_Window_isNonClientWindow00);
   tolua_function(tolua_S,"setNonClientWindow",tolua_CEGUI_CEGUI_Window_setNonClientWindow00);
   tolua_function(tolua_S,"getGeometryBuffer",tolua_CEGUI_CEGUI_Window_getGeometryBuffer00);
   tolua_function(tolua_S,"isTextParsingEnabled",tolua_CEGUI_CEGUI_Window_isTextParsingEnabled00);
   tolua_function(tolua_S,"setTextParsingEnabled",tolua_CEGUI_CEGUI_Window_setTextParsingEnabled00);
   tolua_function(tolua_S,"getUnprojectedPosition",tolua_CEGUI_CEGUI_Window_getUnprojectedPosition00);
   tolua_function(tolua_S,"banPropertyFromXML",tolua_CEGUI_CEGUI_Window_banPropertyFromXML00);
   tolua_function(tolua_S,"unbanPropertyFromXML",tolua_CEGUI_CEGUI_Window_unbanPropertyFromXML00);
   tolua_function(tolua_S,"isPropertyBannedFromXML",tolua_CEGUI_CEGUI_Window_isPropertyBannedFromXML00);
   tolua_function(tolua_S,"setUpdateMode",tolua_CEGUI_CEGUI_Window_setUpdateMode00);
   tolua_function(tolua_S,"getUpdateMode",tolua_CEGUI_CEGUI_Window_getUpdateMode00);
   tolua_function(tolua_S,"setMouseInputPropagationEnabled",tolua_CEGUI_CEGUI_Window_setMouseInputPropagationEnabled00);
   tolua_function(tolua_S,"isMouseInputPropagationEnabled",tolua_CEGUI_CEGUI_Window_isMouseInputPropagationEnabled00);
   tolua_function(tolua_S,"clone",tolua_CEGUI_CEGUI_Window_clone00);
   tolua_function(tolua_S,"getZIndex",tolua_CEGUI_CEGUI_Window_getZIndex00);
   tolua_function(tolua_S,"isInFront",tolua_CEGUI_CEGUI_Window_isInFront00);
   tolua_function(tolua_S,"isBehind",tolua_CEGUI_CEGUI_Window_isBehind00);
   tolua_function(tolua_S,"setProperty",tolua_CEGUI_CEGUI_Window_setProperty00);
   tolua_function(tolua_S,"getProperty",tolua_CEGUI_CEGUI_Window_getProperty00);
   tolua_function(tolua_S,"getPropertyDefault",tolua_CEGUI_CEGUI_Window_getPropertyDefault00);
   tolua_function(tolua_S,"getPropertyHelp",tolua_CEGUI_CEGUI_Window_getPropertyHelp00);
   tolua_function(tolua_S,"isPropertyPresent",tolua_CEGUI_CEGUI_Window_isPropertyPresent00);
   tolua_function(tolua_S,"isPropertyDefault",tolua_CEGUI_CEGUI_Window_isPropertyDefault00);
   tolua_function(tolua_S,"getPropertyIterator",tolua_CEGUI_CEGUI_Window_getPropertyIterator00);
   tolua_function(tolua_S,"addEvent",tolua_CEGUI_CEGUI_Window_addEvent00);
   tolua_function(tolua_S,"removeEvent",tolua_CEGUI_CEGUI_Window_removeEvent00);
   tolua_function(tolua_S,"removeAllEvents",tolua_CEGUI_CEGUI_Window_removeAllEvents00);
   tolua_function(tolua_S,"isEventPresent",tolua_CEGUI_CEGUI_Window_isEventPresent00);
   tolua_function(tolua_S,"subscribeEvent",tolua_CEGUI_CEGUI_Window_subscribeEvent00);
   tolua_function(tolua_S,"subscribeEvent",tolua_CEGUI_CEGUI_Window_subscribeEvent01);
   tolua_function(tolua_S,"fireEvent",tolua_CEGUI_CEGUI_Window_fireEvent00);
   tolua_function(tolua_S,"isMuted",tolua_CEGUI_CEGUI_Window_isMuted00);
   tolua_function(tolua_S,"setMutedState",tolua_CEGUI_CEGUI_Window_setMutedState00);
   tolua_function(tolua_S,"getEventIterator",tolua_CEGUI_CEGUI_Window_getEventIterator00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"CoordConverter","CEGUI::CoordConverter","",NULL);
  tolua_beginmodule(tolua_S,"CoordConverter");
   tolua_function(tolua_S,"windowToScreenX",tolua_CEGUI_CEGUI_CoordConverter_windowToScreenX00);
   tolua_function(tolua_S,"windowToScreenX",tolua_CEGUI_CEGUI_CoordConverter_windowToScreenX01);
   tolua_function(tolua_S,"windowToScreenY",tolua_CEGUI_CEGUI_CoordConverter_windowToScreenY00);
   tolua_function(tolua_S,"windowToScreenY",tolua_CEGUI_CEGUI_CoordConverter_windowToScreenY01);
   tolua_function(tolua_S,"windowToScreen",tolua_CEGUI_CEGUI_CoordConverter_windowToScreen00);
   tolua_function(tolua_S,"windowToScreen",tolua_CEGUI_CEGUI_CoordConverter_windowToScreen01);
   tolua_function(tolua_S,"windowToScreen",tolua_CEGUI_CEGUI_CoordConverter_windowToScreen02);
   tolua_function(tolua_S,"windowToScreen",tolua_CEGUI_CEGUI_CoordConverter_windowToScreen03);
   tolua_function(tolua_S,"screenToWindowX",tolua_CEGUI_CEGUI_CoordConverter_screenToWindowX00);
   tolua_function(tolua_S,"screenToWindowX",tolua_CEGUI_CEGUI_CoordConverter_screenToWindowX01);
   tolua_function(tolua_S,"screenToWindowY",tolua_CEGUI_CEGUI_CoordConverter_screenToWindowY00);
   tolua_function(tolua_S,"screenToWindowY",tolua_CEGUI_CEGUI_CoordConverter_screenToWindowY01);
   tolua_function(tolua_S,"screenToWindow",tolua_CEGUI_CEGUI_CoordConverter_screenToWindow00);
   tolua_function(tolua_S,"screenToWindow",tolua_CEGUI_CEGUI_CoordConverter_screenToWindow01);
   tolua_function(tolua_S,"screenToWindow",tolua_CEGUI_CEGUI_CoordConverter_screenToWindow02);
   tolua_function(tolua_S,"screenToWindow",tolua_CEGUI_CEGUI_CoordConverter_screenToWindow03);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"System","CEGUI::System","CEGUI::EventSet",NULL);
  tolua_beginmodule(tolua_S,"System");
   tolua_function(tolua_S,"getSingleton",tolua_CEGUI_CEGUI_System_getSingleton00);
   tolua_function(tolua_S,"getRenderer",tolua_CEGUI_CEGUI_System_getRenderer00);
   tolua_function(tolua_S,"setDefaultFont",tolua_CEGUI_CEGUI_System_setDefaultFont00);
   tolua_function(tolua_S,"setDefaultFont",tolua_CEGUI_CEGUI_System_setDefaultFont01);
   tolua_function(tolua_S,"getDefaultFont",tolua_CEGUI_CEGUI_System_getDefaultFont00);
   tolua_function(tolua_S,"signalRedraw",tolua_CEGUI_CEGUI_System_signalRedraw00);
   tolua_function(tolua_S,"isRedrawRequested",tolua_CEGUI_CEGUI_System_isRedrawRequested00);
   tolua_function(tolua_S,"renderGUI",tolua_CEGUI_CEGUI_System_renderGUI00);
   tolua_function(tolua_S,"setGUISheet",tolua_CEGUI_CEGUI_System_setGUISheet00);
   tolua_function(tolua_S,"getGUISheet",tolua_CEGUI_CEGUI_System_getGUISheet00);
   tolua_function(tolua_S,"setSingleClickTimeout",tolua_CEGUI_CEGUI_System_setSingleClickTimeout00);
   tolua_function(tolua_S,"setMultiClickTimeout",tolua_CEGUI_CEGUI_System_setMultiClickTimeout00);
   tolua_function(tolua_S,"setMultiClickToleranceAreaSize",tolua_CEGUI_CEGUI_System_setMultiClickToleranceAreaSize00);
   tolua_function(tolua_S,"getSingleClickTimeout",tolua_CEGUI_CEGUI_System_getSingleClickTimeout00);
   tolua_function(tolua_S,"getMultiClickTimeout",tolua_CEGUI_CEGUI_System_getMultiClickTimeout00);
   tolua_function(tolua_S,"getMultiClickToleranceAreaSize",tolua_CEGUI_CEGUI_System_getMultiClickToleranceAreaSize00);
   tolua_function(tolua_S,"isMouseClickEventGenerationEnabled",tolua_CEGUI_CEGUI_System_isMouseClickEventGenerationEnabled00);
   tolua_function(tolua_S,"setMouseClickEventGenerationEnabled",tolua_CEGUI_CEGUI_System_setMouseClickEventGenerationEnabled00);
   tolua_function(tolua_S,"setDefaultMouseCursor",tolua_CEGUI_CEGUI_System_setDefaultMouseCursor00);
   tolua_function(tolua_S,"setDefaultMouseCursor",tolua_CEGUI_CEGUI_System_setDefaultMouseCursor01);
   tolua_function(tolua_S,"setDefaultMouseCursor",tolua_CEGUI_CEGUI_System_setDefaultMouseCursor02);
   tolua_function(tolua_S,"getDefaultMouseCursor",tolua_CEGUI_CEGUI_System_getDefaultMouseCursor00);
   tolua_function(tolua_S,"getWindowContainingMouse",tolua_CEGUI_CEGUI_System_getWindowContainingMouse00);
   tolua_function(tolua_S,"executeScriptFile",tolua_CEGUI_CEGUI_System_executeScriptFile00);
   tolua_function(tolua_S,"executeScriptGlobal",tolua_CEGUI_CEGUI_System_executeScriptGlobal00);
   tolua_function(tolua_S,"executeScriptString",tolua_CEGUI_CEGUI_System_executeScriptString00);
   tolua_function(tolua_S,"getMouseMoveScaling",tolua_CEGUI_CEGUI_System_getMouseMoveScaling00);
   tolua_function(tolua_S,"setMouseMoveScaling",tolua_CEGUI_CEGUI_System_setMouseMoveScaling00);
   tolua_function(tolua_S,"notifyWindowDestroyed",tolua_CEGUI_CEGUI_System_notifyWindowDestroyed00);
   tolua_function(tolua_S,"isSystemKeyDown",tolua_CEGUI_CEGUI_System_isSystemKeyDown00);
   tolua_function(tolua_S,"setDefaultTooltip",tolua_CEGUI_CEGUI_System_setDefaultTooltip00);
   tolua_function(tolua_S,"setDefaultTooltip",tolua_CEGUI_CEGUI_System_setDefaultTooltip01);
   tolua_function(tolua_S,"getDefaultTooltip",tolua_CEGUI_CEGUI_System_getDefaultTooltip00);
   tolua_function(tolua_S,"notifyDisplaySizeChanged",tolua_CEGUI_CEGUI_System_notifyDisplaySizeChanged00);
   tolua_function(tolua_S,"injectMouseMove",tolua_CEGUI_CEGUI_System_injectMouseMove00);
   tolua_function(tolua_S,"injectMouseLeaves",tolua_CEGUI_CEGUI_System_injectMouseLeaves00);
   tolua_function(tolua_S,"injectMouseButtonDown",tolua_CEGUI_CEGUI_System_injectMouseButtonDown00);
   tolua_function(tolua_S,"injectMouseButtonUp",tolua_CEGUI_CEGUI_System_injectMouseButtonUp00);
   tolua_function(tolua_S,"injectKeyDown",tolua_CEGUI_CEGUI_System_injectKeyDown00);
   tolua_function(tolua_S,"injectKeyUp",tolua_CEGUI_CEGUI_System_injectKeyUp00);
   tolua_function(tolua_S,"injectChar",tolua_CEGUI_CEGUI_System_injectChar00);
   tolua_function(tolua_S,"injectMouseWheelChange",tolua_CEGUI_CEGUI_System_injectMouseWheelChange00);
   tolua_function(tolua_S,"injectMousePosition",tolua_CEGUI_CEGUI_System_injectMousePosition00);
   tolua_function(tolua_S,"injectTimePulse",tolua_CEGUI_CEGUI_System_injectTimePulse00);
   tolua_function(tolua_S,"injectMouseButtonClick",tolua_CEGUI_CEGUI_System_injectMouseButtonClick00);
   tolua_function(tolua_S,"injectMouseButtonDoubleClick",tolua_CEGUI_CEGUI_System_injectMouseButtonDoubleClick00);
   tolua_function(tolua_S,"injectMouseButtonTripleClick",tolua_CEGUI_CEGUI_System_injectMouseButtonTripleClick00);
   tolua_function(tolua_S,"getEventIterator",tolua_CEGUI_CEGUI_System_getEventIterator00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"WindowManager","CEGUI::WindowManager","CEGUI::EventSet",NULL);
  tolua_beginmodule(tolua_S,"WindowManager");
   tolua_function(tolua_S,"getSingleton",tolua_CEGUI_CEGUI_WindowManager_getSingleton00);
   tolua_function(tolua_S,"createWindow",tolua_CEGUI_CEGUI_WindowManager_createWindow00);
   tolua_function(tolua_S,"loadWindowLayout",tolua_CEGUI_CEGUI_WindowManager_loadWindowLayout00);
   tolua_function(tolua_S,"writeWindowLayoutToStream",tolua_CEGUI_CEGUI_WindowManager_writeWindowLayoutToStream00);
   tolua_function(tolua_S,"writeWindowLayoutToStream",tolua_CEGUI_CEGUI_WindowManager_writeWindowLayoutToStream01);
   tolua_function(tolua_S,"saveWindowLayout",tolua_CEGUI_CEGUI_WindowManager_saveWindowLayout00);
   tolua_function(tolua_S,"saveWindowLayout",tolua_CEGUI_CEGUI_WindowManager_saveWindowLayout01);
   tolua_function(tolua_S,"destroyWindow",tolua_CEGUI_CEGUI_WindowManager_destroyWindow00);
   tolua_function(tolua_S,"destroyWindow",tolua_CEGUI_CEGUI_WindowManager_destroyWindow01);
   tolua_function(tolua_S,"destroyAllWindows",tolua_CEGUI_CEGUI_WindowManager_destroyAllWindows00);
   tolua_function(tolua_S,"getWindow",tolua_CEGUI_CEGUI_WindowManager_getWindow00);
   tolua_function(tolua_S,"isWindowPresent",tolua_CEGUI_CEGUI_WindowManager_isWindowPresent00);
   tolua_function(tolua_S,"isDeadPoolEmpty",tolua_CEGUI_CEGUI_WindowManager_isDeadPoolEmpty00);
   tolua_function(tolua_S,"cleanDeadPool",tolua_CEGUI_CEGUI_WindowManager_cleanDeadPool00);
   tolua_function(tolua_S,"renameWindow",tolua_CEGUI_CEGUI_WindowManager_renameWindow00);
   tolua_function(tolua_S,"renameWindow",tolua_CEGUI_CEGUI_WindowManager_renameWindow01);
   tolua_function(tolua_S,"getIterator",tolua_CEGUI_CEGUI_WindowManager_getIterator00);
   tolua_function(tolua_S,"setDefaultResourceGroup",tolua_CEGUI_CEGUI_WindowManager_setDefaultResourceGroup00);
   tolua_function(tolua_S,"getDefaultResourceGroup",tolua_CEGUI_CEGUI_WindowManager_getDefaultResourceGroup00);
   tolua_function(tolua_S,"lock",tolua_CEGUI_CEGUI_WindowManager_lock00);
   tolua_function(tolua_S,"unlock",tolua_CEGUI_CEGUI_WindowManager_unlock00);
   tolua_function(tolua_S,"isLocked",tolua_CEGUI_CEGUI_WindowManager_isLocked00);
   tolua_function(tolua_S,"getEventIterator",tolua_CEGUI_CEGUI_WindowManager_getEventIterator00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"FalagardWindowMapping","CEGUI::FalagardWindowMapping","",tolua_collect_CEGUI__FalagardWindowMapping);
  #else
  tolua_cclass(tolua_S,"FalagardWindowMapping","CEGUI::FalagardWindowMapping","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"FalagardWindowMapping");
   tolua_variable(tolua_S,"windowType",tolua_get_CEGUI__FalagardWindowMapping_windowType,tolua_set_CEGUI__FalagardWindowMapping_windowType);
   tolua_variable(tolua_S,"lookName",tolua_get_CEGUI__FalagardWindowMapping_lookName,tolua_set_CEGUI__FalagardWindowMapping_lookName);
   tolua_variable(tolua_S,"baseType",tolua_get_CEGUI__FalagardWindowMapping_baseType,tolua_set_CEGUI__FalagardWindowMapping_baseType);
   tolua_variable(tolua_S,"rendererType",tolua_get_CEGUI__FalagardWindowMapping_rendererType,tolua_set_CEGUI__FalagardWindowMapping_rendererType);
   tolua_variable(tolua_S,"effectName",tolua_get_CEGUI__FalagardWindowMapping_effectName,tolua_set_CEGUI__FalagardWindowMapping_effectName);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"WindowFactory","CEGUI::WindowFactory","",NULL);
  tolua_beginmodule(tolua_S,"WindowFactory");
   tolua_function(tolua_S,"getTypeName",tolua_CEGUI_CEGUI_WindowFactory_getTypeName00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"WindowFactoryManager","CEGUI::WindowFactoryManager","",NULL);
  tolua_beginmodule(tolua_S,"WindowFactoryManager");
   tolua_function(tolua_S,"getSingleton",tolua_CEGUI_CEGUI_WindowFactoryManager_getSingleton00);
   tolua_function(tolua_S,"isFactoryPresent",tolua_CEGUI_CEGUI_WindowFactoryManager_isFactoryPresent00);
   tolua_function(tolua_S,"addWindowTypeAlias",tolua_CEGUI_CEGUI_WindowFactoryManager_addWindowTypeAlias00);
   tolua_function(tolua_S,"removeWindowTypeAlias",tolua_CEGUI_CEGUI_WindowFactoryManager_removeWindowTypeAlias00);
   tolua_function(tolua_S,"addFalagardWindowMapping",tolua_CEGUI_CEGUI_WindowFactoryManager_addFalagardWindowMapping00);
   tolua_function(tolua_S,"removeFalagardWindowMapping",tolua_CEGUI_CEGUI_WindowFactoryManager_removeFalagardWindowMapping00);
   tolua_function(tolua_S,"isFalagardMappedType",tolua_CEGUI_CEGUI_WindowFactoryManager_isFalagardMappedType00);
   tolua_function(tolua_S,"getMappedLookForType",tolua_CEGUI_CEGUI_WindowFactoryManager_getMappedLookForType00);
   tolua_function(tolua_S,"getMappedRendererForType",tolua_CEGUI_CEGUI_WindowFactoryManager_getMappedRendererForType00);
   tolua_function(tolua_S,"getDereferencedAliasType",tolua_CEGUI_CEGUI_WindowFactoryManager_getDereferencedAliasType00);
   tolua_function(tolua_S,"getFalagardMappingForType",tolua_CEGUI_CEGUI_WindowFactoryManager_getFalagardMappingForType00);
   tolua_function(tolua_S,"getIterator",tolua_CEGUI_CEGUI_WindowFactoryManager_getIterator00);
   tolua_function(tolua_S,"getFalagardMappingIterator",tolua_CEGUI_CEGUI_WindowFactoryManager_getFalagardMappingIterator00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Scheme","CEGUI::Scheme","",NULL);
  tolua_beginmodule(tolua_S,"Scheme");
   tolua_function(tolua_S,"loadResources",tolua_CEGUI_CEGUI_Scheme_loadResources00);
   tolua_function(tolua_S,"unloadResources",tolua_CEGUI_CEGUI_Scheme_unloadResources00);
   tolua_function(tolua_S,"resourcesLoaded",tolua_CEGUI_CEGUI_Scheme_resourcesLoaded00);
   tolua_function(tolua_S,"getName",tolua_CEGUI_CEGUI_Scheme_getName00);
   tolua_function(tolua_S,"setDefaultResourceGroup",tolua_CEGUI_CEGUI_Scheme_setDefaultResourceGroup00);
   tolua_function(tolua_S,"getDefaultResourceGroup",tolua_CEGUI_CEGUI_Scheme_getDefaultResourceGroup00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"SchemeManager","CEGUI::SchemeManager","",NULL);
  tolua_beginmodule(tolua_S,"SchemeManager");
   tolua_function(tolua_S,"getSingleton",tolua_CEGUI_CEGUI_SchemeManager_getSingleton00);
   tolua_function(tolua_S,"create",tolua_CEGUI_CEGUI_SchemeManager_create00);
   tolua_function(tolua_S,"destroy",tolua_CEGUI_CEGUI_SchemeManager_destroy00);
   tolua_function(tolua_S,"isDefined",tolua_CEGUI_CEGUI_SchemeManager_isDefined00);
   tolua_function(tolua_S,"get",tolua_CEGUI_CEGUI_SchemeManager_get00);
   tolua_function(tolua_S,"destroyAll",tolua_CEGUI_CEGUI_SchemeManager_destroyAll00);
   tolua_function(tolua_S,"getIterator",tolua_CEGUI_CEGUI_SchemeManager_getIterator00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"PropertyHelper","CEGUI::PropertyHelper","",NULL);
  tolua_beginmodule(tolua_S,"PropertyHelper");
   tolua_function(tolua_S,"stringToFloat",tolua_CEGUI_CEGUI_PropertyHelper_stringToFloat00);
   tolua_function(tolua_S,"stringToUint",tolua_CEGUI_CEGUI_PropertyHelper_stringToUint00);
   tolua_function(tolua_S,"stringToBool",tolua_CEGUI_CEGUI_PropertyHelper_stringToBool00);
   tolua_function(tolua_S,"stringToSize",tolua_CEGUI_CEGUI_PropertyHelper_stringToSize00);
   tolua_function(tolua_S,"stringToPoint",tolua_CEGUI_CEGUI_PropertyHelper_stringToPoint00);
   tolua_function(tolua_S,"stringToRect",tolua_CEGUI_CEGUI_PropertyHelper_stringToRect00);
   tolua_function(tolua_S,"stringToImage",tolua_CEGUI_CEGUI_PropertyHelper_stringToImage00);
   tolua_function(tolua_S,"stringToColour",tolua_CEGUI_CEGUI_PropertyHelper_stringToColour00);
   tolua_function(tolua_S,"stringToColourRect",tolua_CEGUI_CEGUI_PropertyHelper_stringToColourRect00);
   tolua_function(tolua_S,"stringToUDim",tolua_CEGUI_CEGUI_PropertyHelper_stringToUDim00);
   tolua_function(tolua_S,"stringToUVector2",tolua_CEGUI_CEGUI_PropertyHelper_stringToUVector200);
   tolua_function(tolua_S,"stringToURect",tolua_CEGUI_CEGUI_PropertyHelper_stringToURect00);
   tolua_function(tolua_S,"floatToString",tolua_CEGUI_CEGUI_PropertyHelper_floatToString00);
   tolua_function(tolua_S,"uintToString",tolua_CEGUI_CEGUI_PropertyHelper_uintToString00);
   tolua_function(tolua_S,"boolToString",tolua_CEGUI_CEGUI_PropertyHelper_boolToString00);
   tolua_function(tolua_S,"sizeToString",tolua_CEGUI_CEGUI_PropertyHelper_sizeToString00);
   tolua_function(tolua_S,"pointToString",tolua_CEGUI_CEGUI_PropertyHelper_pointToString00);
   tolua_function(tolua_S,"rectToString",tolua_CEGUI_CEGUI_PropertyHelper_rectToString00);
   tolua_function(tolua_S,"imageToString",tolua_CEGUI_CEGUI_PropertyHelper_imageToString00);
   tolua_function(tolua_S,"colourToString",tolua_CEGUI_CEGUI_PropertyHelper_colourToString00);
   tolua_function(tolua_S,"colourRectToString",tolua_CEGUI_CEGUI_PropertyHelper_colourRectToString00);
   tolua_function(tolua_S,"udimToString",tolua_CEGUI_CEGUI_PropertyHelper_udimToString00);
   tolua_function(tolua_S,"uvector2ToString",tolua_CEGUI_CEGUI_PropertyHelper_uvector2ToString00);
   tolua_function(tolua_S,"urectToString",tolua_CEGUI_CEGUI_PropertyHelper_urectToString00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Vertex","CEGUI::Vertex","",NULL);
  tolua_beginmodule(tolua_S,"Vertex");
   tolua_variable(tolua_S,"position",tolua_get_CEGUI__Vertex_position,tolua_set_CEGUI__Vertex_position);
   tolua_variable(tolua_S,"tex_coords",tolua_get_CEGUI__Vertex_tex_coords,tolua_set_CEGUI__Vertex_tex_coords);
   tolua_variable(tolua_S,"colour_val",tolua_get_CEGUI__Vertex_colour_val,tolua_set_CEGUI__Vertex_colour_val);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"RenderingContext","CEGUI::RenderingContext","",NULL);
  tolua_beginmodule(tolua_S,"RenderingContext");
   tolua_variable(tolua_S,"surface",tolua_get_CEGUI__RenderingContext_surface_ptr,tolua_set_CEGUI__RenderingContext_surface_ptr);
   tolua_variable(tolua_S,"owner",tolua_get_CEGUI__RenderingContext_owner_ptr,NULL);
   tolua_variable(tolua_S,"offset",tolua_get_CEGUI__RenderingContext_offset,tolua_set_CEGUI__RenderingContext_offset);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"RenderEffect","CEGUI::RenderEffect","",NULL);
  tolua_beginmodule(tolua_S,"RenderEffect");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"GeometryBuffer","CEGUI::GeometryBuffer","",NULL);
  tolua_beginmodule(tolua_S,"GeometryBuffer");
   tolua_function(tolua_S,"draw",tolua_CEGUI_CEGUI_GeometryBuffer_draw00);
   tolua_function(tolua_S,"setTranslation",tolua_CEGUI_CEGUI_GeometryBuffer_setTranslation00);
   tolua_function(tolua_S,"setRotation",tolua_CEGUI_CEGUI_GeometryBuffer_setRotation00);
   tolua_function(tolua_S,"setPivot",tolua_CEGUI_CEGUI_GeometryBuffer_setPivot00);
   tolua_function(tolua_S,"appendVertex",tolua_CEGUI_CEGUI_GeometryBuffer_appendVertex00);
   tolua_function(tolua_S,"appendGeometry",tolua_CEGUI_CEGUI_GeometryBuffer_appendGeometry00);
   tolua_function(tolua_S,"setActiveTexture",tolua_CEGUI_CEGUI_GeometryBuffer_setActiveTexture00);
   tolua_function(tolua_S,"reset",tolua_CEGUI_CEGUI_GeometryBuffer_reset00);
   tolua_function(tolua_S,"getActiveTexture",tolua_CEGUI_CEGUI_GeometryBuffer_getActiveTexture00);
   tolua_function(tolua_S,"getVertexCount",tolua_CEGUI_CEGUI_GeometryBuffer_getVertexCount00);
   tolua_function(tolua_S,"getBatchCount",tolua_CEGUI_CEGUI_GeometryBuffer_getBatchCount00);
   tolua_function(tolua_S,"setRenderEffect",tolua_CEGUI_CEGUI_GeometryBuffer_setRenderEffect00);
   tolua_function(tolua_S,"getRenderEffect",tolua_CEGUI_CEGUI_GeometryBuffer_getRenderEffect00);
  tolua_endmodule(tolua_S);
  tolua_constant(tolua_S,"RQ_USER_0",CEGUI::RQ_USER_0);
  tolua_constant(tolua_S,"RQ_UNDERLAY",CEGUI::RQ_UNDERLAY);
  tolua_constant(tolua_S,"RQ_USER_1",CEGUI::RQ_USER_1);
  tolua_constant(tolua_S,"RQ_BASE",CEGUI::RQ_BASE);
  tolua_constant(tolua_S,"RQ_USER_2",CEGUI::RQ_USER_2);
  tolua_constant(tolua_S,"RQ_CONTENT_1",CEGUI::RQ_CONTENT_1);
  tolua_constant(tolua_S,"RQ_USER_3",CEGUI::RQ_USER_3);
  tolua_constant(tolua_S,"RQ_CONTENT_2",CEGUI::RQ_CONTENT_2);
  tolua_constant(tolua_S,"RQ_USER_4",CEGUI::RQ_USER_4);
  tolua_constant(tolua_S,"RQ_OVERLAY",CEGUI::RQ_OVERLAY);
  tolua_constant(tolua_S,"RQ_USER_5",CEGUI::RQ_USER_5);
  tolua_cclass(tolua_S,"RenderingSurface","CEGUI::RenderingSurface","CEGUI::EventSet",NULL);
  tolua_beginmodule(tolua_S,"RenderingSurface");
   tolua_function(tolua_S,"addGeometryBuffer",tolua_CEGUI_CEGUI_RenderingSurface_addGeometryBuffer00);
   tolua_function(tolua_S,"removeGeometryBuffer",tolua_CEGUI_CEGUI_RenderingSurface_removeGeometryBuffer00);
   tolua_function(tolua_S,"clearGeometry",tolua_CEGUI_CEGUI_RenderingSurface_clearGeometry00);
   tolua_function(tolua_S,"clearGeometry",tolua_CEGUI_CEGUI_RenderingSurface_clearGeometry01);
   tolua_function(tolua_S,"invalidate",tolua_CEGUI_CEGUI_RenderingSurface_invalidate00);
   tolua_function(tolua_S,"isInvalidated",tolua_CEGUI_CEGUI_RenderingSurface_isInvalidated00);
   tolua_function(tolua_S,"isRenderingWindow",tolua_CEGUI_CEGUI_RenderingSurface_isRenderingWindow00);
   tolua_function(tolua_S,"transferRenderingWindow",tolua_CEGUI_CEGUI_RenderingSurface_transferRenderingWindow00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"RenderingRoot","CEGUI::RenderingRoot","CEGUI::RenderingSurface",NULL);
  tolua_beginmodule(tolua_S,"RenderingRoot");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"RenderingWindow","CEGUI::RenderingWindow","CEGUI::RenderingSurface",NULL);
  tolua_beginmodule(tolua_S,"RenderingWindow");
   tolua_function(tolua_S,"setClippingRegion",tolua_CEGUI_CEGUI_RenderingWindow_setClippingRegion00);
   tolua_function(tolua_S,"setPosition",tolua_CEGUI_CEGUI_RenderingWindow_setPosition00);
   tolua_function(tolua_S,"setSize",tolua_CEGUI_CEGUI_RenderingWindow_setSize00);
   tolua_function(tolua_S,"setRotation",tolua_CEGUI_CEGUI_RenderingWindow_setRotation00);
   tolua_function(tolua_S,"setPivot",tolua_CEGUI_CEGUI_RenderingWindow_setPivot00);
   tolua_function(tolua_S,"getPosition",tolua_CEGUI_CEGUI_RenderingWindow_getPosition00);
   tolua_function(tolua_S,"getSize",tolua_CEGUI_CEGUI_RenderingWindow_getSize00);
   tolua_function(tolua_S,"getRotation",tolua_CEGUI_CEGUI_RenderingWindow_getRotation00);
   tolua_function(tolua_S,"getPivot",tolua_CEGUI_CEGUI_RenderingWindow_getPivot00);
   tolua_function(tolua_S,"setRenderEffect",tolua_CEGUI_CEGUI_RenderingWindow_setRenderEffect00);
   tolua_function(tolua_S,"getRenderEffect",tolua_CEGUI_CEGUI_RenderingWindow_getRenderEffect00);
   tolua_function(tolua_S,"getOwner",tolua_CEGUI_CEGUI_RenderingWindow_getOwner00);
   tolua_function(tolua_S,"getOwner",tolua_CEGUI_CEGUI_RenderingWindow_getOwner01);
   tolua_function(tolua_S,"unprojectPoint",tolua_CEGUI_CEGUI_RenderingWindow_unprojectPoint00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Renderer","CEGUI::Renderer","",NULL);
  tolua_beginmodule(tolua_S,"Renderer");
   tolua_function(tolua_S,"getDefaultRenderingRoot",tolua_CEGUI_CEGUI_Renderer_getDefaultRenderingRoot00);
   tolua_function(tolua_S,"createGeometryBuffer",tolua_CEGUI_CEGUI_Renderer_createGeometryBuffer00);
   tolua_function(tolua_S,"destroyGeometryBuffer",tolua_CEGUI_CEGUI_Renderer_destroyGeometryBuffer00);
   tolua_function(tolua_S,"destroyAllGeometryBuffers",tolua_CEGUI_CEGUI_Renderer_destroyAllGeometryBuffers00);
   tolua_function(tolua_S,"createTexture",tolua_CEGUI_CEGUI_Renderer_createTexture00);
   tolua_function(tolua_S,"createTexture",tolua_CEGUI_CEGUI_Renderer_createTexture01);
   tolua_function(tolua_S,"createTexture",tolua_CEGUI_CEGUI_Renderer_createTexture02);
   tolua_function(tolua_S,"destroyTexture",tolua_CEGUI_CEGUI_Renderer_destroyTexture00);
   tolua_function(tolua_S,"destroyAllTextures",tolua_CEGUI_CEGUI_Renderer_destroyAllTextures00);
   tolua_function(tolua_S,"setDisplaySize",tolua_CEGUI_CEGUI_Renderer_setDisplaySize00);
   tolua_function(tolua_S,"getDisplaySize",tolua_CEGUI_CEGUI_Renderer_getDisplaySize00);
   tolua_function(tolua_S,"getDisplayDPI",tolua_CEGUI_CEGUI_Renderer_getDisplayDPI00);
   tolua_function(tolua_S,"getMaxTextureSize",tolua_CEGUI_CEGUI_Renderer_getMaxTextureSize00);
   tolua_function(tolua_S,"getIdentifierString",tolua_CEGUI_CEGUI_Renderer_getIdentifierString00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Texture","CEGUI::Texture","",NULL);
  tolua_beginmodule(tolua_S,"Texture");
   tolua_constant(tolua_S,"PF_RGB",CEGUI::Texture::PF_RGB);
   tolua_constant(tolua_S,"PF_RGBA",CEGUI::Texture::PF_RGBA);
   tolua_function(tolua_S,"getSize",tolua_CEGUI_CEGUI_Texture_getSize00);
   tolua_function(tolua_S,"getOriginalDataSize",tolua_CEGUI_CEGUI_Texture_getOriginalDataSize00);
   tolua_function(tolua_S,"getTexelScaling",tolua_CEGUI_CEGUI_Texture_getTexelScaling00);
   tolua_function(tolua_S,"loadFromFile",tolua_CEGUI_CEGUI_Texture_loadFromFile00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"KeyFrame","CEGUI::KeyFrame","",NULL);
  tolua_beginmodule(tolua_S,"KeyFrame");
   tolua_constant(tolua_S,"P_Linear",CEGUI::KeyFrame::P_Linear);
   tolua_constant(tolua_S,"P_QuadraticAccelerating",CEGUI::KeyFrame::P_QuadraticAccelerating);
   tolua_constant(tolua_S,"P_QuadraticDecelerating",CEGUI::KeyFrame::P_QuadraticDecelerating);
   tolua_constant(tolua_S,"P_Discrete",CEGUI::KeyFrame::P_Discrete);
   tolua_function(tolua_S,"getParent",tolua_CEGUI_CEGUI_KeyFrame_getParent00);
   tolua_function(tolua_S,"getPosition",tolua_CEGUI_CEGUI_KeyFrame_getPosition00);
   tolua_function(tolua_S,"setValue",tolua_CEGUI_CEGUI_KeyFrame_setValue00);
   tolua_function(tolua_S,"getValue",tolua_CEGUI_CEGUI_KeyFrame_getValue00);
   tolua_function(tolua_S,"setProgression",tolua_CEGUI_CEGUI_KeyFrame_setProgression00);
   tolua_function(tolua_S,"getProgression",tolua_CEGUI_CEGUI_KeyFrame_getProgression00);
   tolua_function(tolua_S,"alterInterpolationPosition",tolua_CEGUI_CEGUI_KeyFrame_alterInterpolationPosition00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Affector","CEGUI::Affector","",NULL);
  tolua_beginmodule(tolua_S,"Affector");
   tolua_constant(tolua_S,"AM_Absolute",CEGUI::Affector::AM_Absolute);
   tolua_constant(tolua_S,"AM_Relative",CEGUI::Affector::AM_Relative);
   tolua_function(tolua_S,"setApplicationMethod",tolua_CEGUI_CEGUI_Affector_setApplicationMethod00);
   tolua_function(tolua_S,"getApplicationMethod",tolua_CEGUI_CEGUI_Affector_getApplicationMethod00);
   tolua_function(tolua_S,"setTargetProperty",tolua_CEGUI_CEGUI_Affector_setTargetProperty00);
   tolua_function(tolua_S,"getTargetProperty",tolua_CEGUI_CEGUI_Affector_getTargetProperty00);
   tolua_function(tolua_S,"setInterpolator",tolua_CEGUI_CEGUI_Affector_setInterpolator00);
   tolua_function(tolua_S,"setInterpolator",tolua_CEGUI_CEGUI_Affector_setInterpolator01);
   tolua_function(tolua_S,"getInterpolator",tolua_CEGUI_CEGUI_Affector_getInterpolator00);
   tolua_function(tolua_S,"createKeyFrame",tolua_CEGUI_CEGUI_Affector_createKeyFrame00);
   tolua_function(tolua_S,"createKeyFrame",tolua_CEGUI_CEGUI_Affector_createKeyFrame01);
   tolua_function(tolua_S,"destroyKeyFrame",tolua_CEGUI_CEGUI_Affector_destroyKeyFrame00);
   tolua_function(tolua_S,"getKeyFrameAtPosition",tolua_CEGUI_CEGUI_Affector_getKeyFrameAtPosition00);
   tolua_function(tolua_S,"getKeyFrameAtIdx",tolua_CEGUI_CEGUI_Affector_getKeyFrameAtIdx00);
   tolua_function(tolua_S,"getNumKeyFrames",tolua_CEGUI_CEGUI_Affector_getNumKeyFrames00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"AnimationEventArgs","CEGUI::AnimationEventArgs","CEGUI::EventArgs",NULL);
  tolua_beginmodule(tolua_S,"AnimationEventArgs");
   tolua_variable(tolua_S,"instance",tolua_get_CEGUI__AnimationEventArgs_instance_ptr,tolua_set_CEGUI__AnimationEventArgs_instance_ptr);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"AnimationInstance","CEGUI::AnimationInstance","",NULL);
  tolua_beginmodule(tolua_S,"AnimationInstance");
   tolua_function(tolua_S,"getDefinition",tolua_CEGUI_CEGUI_AnimationInstance_getDefinition00);
   tolua_function(tolua_S,"setEventReceiver",tolua_CEGUI_CEGUI_AnimationInstance_setEventReceiver00);
   tolua_function(tolua_S,"getEventReceiver",tolua_CEGUI_CEGUI_AnimationInstance_getEventReceiver00);
   tolua_function(tolua_S,"setEventSender",tolua_CEGUI_CEGUI_AnimationInstance_setEventSender00);
   tolua_function(tolua_S,"getEventSender",tolua_CEGUI_CEGUI_AnimationInstance_getEventSender00);
   tolua_function(tolua_S,"setTargetWindow",tolua_CEGUI_CEGUI_AnimationInstance_setTargetWindow00);
   tolua_function(tolua_S,"setPosition",tolua_CEGUI_CEGUI_AnimationInstance_setPosition00);
   tolua_function(tolua_S,"getPosition",tolua_CEGUI_CEGUI_AnimationInstance_getPosition00);
   tolua_function(tolua_S,"setSpeed",tolua_CEGUI_CEGUI_AnimationInstance_setSpeed00);
   tolua_function(tolua_S,"getSpeed",tolua_CEGUI_CEGUI_AnimationInstance_getSpeed00);
   tolua_function(tolua_S,"start",tolua_CEGUI_CEGUI_AnimationInstance_start00);
   tolua_function(tolua_S,"stop",tolua_CEGUI_CEGUI_AnimationInstance_stop00);
   tolua_function(tolua_S,"pause",tolua_CEGUI_CEGUI_AnimationInstance_pause00);
   tolua_function(tolua_S,"unpause",tolua_CEGUI_CEGUI_AnimationInstance_unpause00);
   tolua_function(tolua_S,"togglePause",tolua_CEGUI_CEGUI_AnimationInstance_togglePause00);
   tolua_function(tolua_S,"isRunning",tolua_CEGUI_CEGUI_AnimationInstance_isRunning00);
   tolua_function(tolua_S,"step",tolua_CEGUI_CEGUI_AnimationInstance_step00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Animation","CEGUI::Animation","",NULL);
  tolua_beginmodule(tolua_S,"Animation");
   tolua_constant(tolua_S,"RM_Once",CEGUI::Animation::RM_Once);
   tolua_constant(tolua_S,"RM_Loop",CEGUI::Animation::RM_Loop);
   tolua_constant(tolua_S,"RM_Bounce",CEGUI::Animation::RM_Bounce);
   tolua_function(tolua_S,"getName",tolua_CEGUI_CEGUI_Animation_getName00);
   tolua_function(tolua_S,"setReplayMode",tolua_CEGUI_CEGUI_Animation_setReplayMode00);
   tolua_function(tolua_S,"getReplayMode",tolua_CEGUI_CEGUI_Animation_getReplayMode00);
   tolua_function(tolua_S,"setDuration",tolua_CEGUI_CEGUI_Animation_setDuration00);
   tolua_function(tolua_S,"getDuration",tolua_CEGUI_CEGUI_Animation_getDuration00);
   tolua_function(tolua_S,"setAutoStart",tolua_CEGUI_CEGUI_Animation_setAutoStart00);
   tolua_function(tolua_S,"getAutoStart",tolua_CEGUI_CEGUI_Animation_getAutoStart00);
   tolua_function(tolua_S,"createAffector",tolua_CEGUI_CEGUI_Animation_createAffector00);
   tolua_function(tolua_S,"createAffector",tolua_CEGUI_CEGUI_Animation_createAffector01);
   tolua_function(tolua_S,"destroyAffector",tolua_CEGUI_CEGUI_Animation_destroyAffector00);
   tolua_function(tolua_S,"getAffectorAtIdx",tolua_CEGUI_CEGUI_Animation_getAffectorAtIdx00);
   tolua_function(tolua_S,"getNumAffectors",tolua_CEGUI_CEGUI_Animation_getNumAffectors00);
   tolua_function(tolua_S,"defineAutoSubscription",tolua_CEGUI_CEGUI_Animation_defineAutoSubscription00);
   tolua_function(tolua_S,"undefineAutoSubscription",tolua_CEGUI_CEGUI_Animation_undefineAutoSubscription00);
   tolua_function(tolua_S,"undefineAllAutoSubscriptions",tolua_CEGUI_CEGUI_Animation_undefineAllAutoSubscriptions00);
   tolua_function(tolua_S,"autoSubscribe",tolua_CEGUI_CEGUI_Animation_autoSubscribe00);
   tolua_function(tolua_S,"autoUnsubscribe",tolua_CEGUI_CEGUI_Animation_autoUnsubscribe00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"AnimationManager","CEGUI::AnimationManager","",NULL);
  tolua_beginmodule(tolua_S,"AnimationManager");
   tolua_function(tolua_S,"getSingleton",tolua_CEGUI_CEGUI_AnimationManager_getSingleton00);
   tolua_function(tolua_S,"addInterpolator",tolua_CEGUI_CEGUI_AnimationManager_addInterpolator00);
   tolua_function(tolua_S,"removeInterpolator",tolua_CEGUI_CEGUI_AnimationManager_removeInterpolator00);
   tolua_function(tolua_S,"getInterpolator",tolua_CEGUI_CEGUI_AnimationManager_getInterpolator00);
   tolua_function(tolua_S,"createAnimation",tolua_CEGUI_CEGUI_AnimationManager_createAnimation00);
   tolua_function(tolua_S,"destroyAnimation",tolua_CEGUI_CEGUI_AnimationManager_destroyAnimation00);
   tolua_function(tolua_S,"destroyAnimation",tolua_CEGUI_CEGUI_AnimationManager_destroyAnimation01);
   tolua_function(tolua_S,"getAnimation",tolua_CEGUI_CEGUI_AnimationManager_getAnimation00);
   tolua_function(tolua_S,"getAnimationAtIdx",tolua_CEGUI_CEGUI_AnimationManager_getAnimationAtIdx00);
   tolua_function(tolua_S,"getNumAnimations",tolua_CEGUI_CEGUI_AnimationManager_getNumAnimations00);
   tolua_function(tolua_S,"instantiateAnimation",tolua_CEGUI_CEGUI_AnimationManager_instantiateAnimation00);
   tolua_function(tolua_S,"instantiateAnimation",tolua_CEGUI_CEGUI_AnimationManager_instantiateAnimation01);
   tolua_function(tolua_S,"destroyAnimationInstance",tolua_CEGUI_CEGUI_AnimationManager_destroyAnimationInstance00);
   tolua_function(tolua_S,"destroyAllInstancesOfAnimation",tolua_CEGUI_CEGUI_AnimationManager_destroyAllInstancesOfAnimation00);
   tolua_function(tolua_S,"getAnimationInstanceAtIdx",tolua_CEGUI_CEGUI_AnimationManager_getAnimationInstanceAtIdx00);
   tolua_function(tolua_S,"getNumAnimationInstances",tolua_CEGUI_CEGUI_AnimationManager_getNumAnimationInstances00);
   tolua_function(tolua_S,"stepInstances",tolua_CEGUI_CEGUI_AnimationManager_stepInstances00);
   tolua_function(tolua_S,"loadAnimationsFromXML",tolua_CEGUI_CEGUI_AnimationManager_loadAnimationsFromXML00);
   tolua_function(tolua_S,"setDefaultResourceGroup",tolua_CEGUI_CEGUI_AnimationManager_setDefaultResourceGroup00);
   tolua_function(tolua_S,"getDefaultResourceGroup",tolua_CEGUI_CEGUI_AnimationManager_getDefaultResourceGroup00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Interpolator","CEGUI::Interpolator","",NULL);
  tolua_beginmodule(tolua_S,"Interpolator");
   tolua_function(tolua_S,"getType",tolua_CEGUI_CEGUI_Interpolator_getType00);
   tolua_function(tolua_S,"interpolateAbsolute",tolua_CEGUI_CEGUI_Interpolator_interpolateAbsolute00);
   tolua_function(tolua_S,"interpolateRelative",tolua_CEGUI_CEGUI_Interpolator_interpolateRelative00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"GUISheet","CEGUI::GUISheet","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"GUISheet");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Tree","CEGUI::Tree","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"Tree");
   tolua_function(tolua_S,"getItemCount",tolua_CEGUI_CEGUI_Tree_getItemCount00);
   tolua_function(tolua_S,"getSelectedCount",tolua_CEGUI_CEGUI_Tree_getSelectedCount00);
   tolua_function(tolua_S,"getFirstSelectedItem",tolua_CEGUI_CEGUI_Tree_getFirstSelectedItem00);
   tolua_function(tolua_S,"getLastSelectedItem",tolua_CEGUI_CEGUI_Tree_getLastSelectedItem00);
   tolua_function(tolua_S,"isSortEnabled",tolua_CEGUI_CEGUI_Tree_isSortEnabled00);
   tolua_function(tolua_S,"isMultiselectEnabled",tolua_CEGUI_CEGUI_Tree_isMultiselectEnabled00);
   tolua_function(tolua_S,"isItemTooltipsEnabled",tolua_CEGUI_CEGUI_Tree_isItemTooltipsEnabled00);
   tolua_function(tolua_S,"findFirstItemWithText",tolua_CEGUI_CEGUI_Tree_findFirstItemWithText00);
   tolua_function(tolua_S,"findNextItemWithText",tolua_CEGUI_CEGUI_Tree_findNextItemWithText00);
   tolua_function(tolua_S,"findFirstItemWithID",tolua_CEGUI_CEGUI_Tree_findFirstItemWithID00);
   tolua_function(tolua_S,"findNextItemWithID",tolua_CEGUI_CEGUI_Tree_findNextItemWithID00);
   tolua_function(tolua_S,"isTreeItemInList",tolua_CEGUI_CEGUI_Tree_isTreeItemInList00);
   tolua_function(tolua_S,"resetList",tolua_CEGUI_CEGUI_Tree_resetList00);
   tolua_function(tolua_S,"addItem",tolua_CEGUI_CEGUI_Tree_addItem00);
   tolua_function(tolua_S,"insertItem",tolua_CEGUI_CEGUI_Tree_insertItem00);
   tolua_function(tolua_S,"removeItem",tolua_CEGUI_CEGUI_Tree_removeItem00);
   tolua_function(tolua_S,"clearAllSelections",tolua_CEGUI_CEGUI_Tree_clearAllSelections00);
   tolua_function(tolua_S,"setSortingEnabled",tolua_CEGUI_CEGUI_Tree_setSortingEnabled00);
   tolua_function(tolua_S,"setMultiselectEnabled",tolua_CEGUI_CEGUI_Tree_setMultiselectEnabled00);
   tolua_function(tolua_S,"setItemSelectState",tolua_CEGUI_CEGUI_Tree_setItemSelectState00);
   tolua_function(tolua_S,"setItemSelectState",tolua_CEGUI_CEGUI_Tree_setItemSelectState01);
   tolua_function(tolua_S,"ensureItemIsVisible",tolua_CEGUI_CEGUI_Tree_ensureItemIsVisible00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ButtonBase","CEGUI::ButtonBase","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"ButtonBase");
   tolua_function(tolua_S,"isHovering",tolua_CEGUI_CEGUI_ButtonBase_isHovering00);
   tolua_function(tolua_S,"isPushed",tolua_CEGUI_CEGUI_ButtonBase_isPushed00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Checkbox","CEGUI::Checkbox","CEGUI::ButtonBase",NULL);
  tolua_beginmodule(tolua_S,"Checkbox");
   tolua_function(tolua_S,"isSelected",tolua_CEGUI_CEGUI_Checkbox_isSelected00);
   tolua_function(tolua_S,"setSelected",tolua_CEGUI_CEGUI_Checkbox_setSelected00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"PushButton","CEGUI::PushButton","CEGUI::ButtonBase",NULL);
  tolua_beginmodule(tolua_S,"PushButton");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Thumb","CEGUI::Thumb","CEGUI::PushButton",NULL);
  tolua_beginmodule(tolua_S,"Thumb");
   tolua_function(tolua_S,"isHotTracked",tolua_CEGUI_CEGUI_Thumb_isHotTracked00);
   tolua_function(tolua_S,"isVertFree",tolua_CEGUI_CEGUI_Thumb_isVertFree00);
   tolua_function(tolua_S,"isHorzFree",tolua_CEGUI_CEGUI_Thumb_isHorzFree00);
   tolua_function(tolua_S,"setHotTracked",tolua_CEGUI_CEGUI_Thumb_setHotTracked00);
   tolua_function(tolua_S,"setVertFree",tolua_CEGUI_CEGUI_Thumb_setVertFree00);
   tolua_function(tolua_S,"setHorzFree",tolua_CEGUI_CEGUI_Thumb_setHorzFree00);
   tolua_function(tolua_S,"getVertRange",tolua_CEGUI_CEGUI_Thumb_getVertRange00);
   tolua_function(tolua_S,"getHorzRange",tolua_CEGUI_CEGUI_Thumb_getHorzRange00);
   tolua_function(tolua_S,"setVertRange",tolua_CEGUI_CEGUI_Thumb_setVertRange00);
   tolua_function(tolua_S,"setHorzRange",tolua_CEGUI_CEGUI_Thumb_setHorzRange00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"RadioButton","CEGUI::RadioButton","CEGUI::ButtonBase",NULL);
  tolua_beginmodule(tolua_S,"RadioButton");
   tolua_function(tolua_S,"isSelected",tolua_CEGUI_CEGUI_RadioButton_isSelected00);
   tolua_function(tolua_S,"setSelected",tolua_CEGUI_CEGUI_RadioButton_setSelected00);
   tolua_function(tolua_S,"getGroupID",tolua_CEGUI_CEGUI_RadioButton_getGroupID00);
   tolua_function(tolua_S,"setGroupID",tolua_CEGUI_CEGUI_RadioButton_setGroupID00);
   tolua_function(tolua_S,"getSelectedButtonInGroup",tolua_CEGUI_CEGUI_RadioButton_getSelectedButtonInGroup00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"TabButton","CEGUI::TabButton","CEGUI::ButtonBase",NULL);
  tolua_beginmodule(tolua_S,"TabButton");
   tolua_function(tolua_S,"isSelected",tolua_CEGUI_CEGUI_TabButton_isSelected00);
   tolua_function(tolua_S,"setSelected",tolua_CEGUI_CEGUI_TabButton_setSelected00);
   tolua_function(tolua_S,"setTargetWindow",tolua_CEGUI_CEGUI_TabButton_setTargetWindow00);
   tolua_function(tolua_S,"getTargetWindow",tolua_CEGUI_CEGUI_TabButton_getTargetWindow00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"TabControl","CEGUI::TabControl","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"TabControl");
   tolua_function(tolua_S,"getTabCount",tolua_CEGUI_CEGUI_TabControl_getTabCount00);
   tolua_function(tolua_S,"setSelectedTab",tolua_CEGUI_CEGUI_TabControl_setSelectedTab00);
   tolua_function(tolua_S,"setSelectedTab",tolua_CEGUI_CEGUI_TabControl_setSelectedTab01);
   tolua_function(tolua_S,"setSelectedTabAtIndex",tolua_CEGUI_CEGUI_TabControl_setSelectedTabAtIndex00);
   tolua_function(tolua_S,"getTabContentsAtIndex",tolua_CEGUI_CEGUI_TabControl_getTabContentsAtIndex00);
   tolua_function(tolua_S,"getTabContents",tolua_CEGUI_CEGUI_TabControl_getTabContents00);
   tolua_function(tolua_S,"getTabContents",tolua_CEGUI_CEGUI_TabControl_getTabContents01);
   tolua_function(tolua_S,"isTabContentsSelected",tolua_CEGUI_CEGUI_TabControl_isTabContentsSelected00);
   tolua_function(tolua_S,"getSelectedTabIndex",tolua_CEGUI_CEGUI_TabControl_getSelectedTabIndex00);
   tolua_function(tolua_S,"getTabHeight",tolua_CEGUI_CEGUI_TabControl_getTabHeight00);
   tolua_function(tolua_S,"getTabTextPadding",tolua_CEGUI_CEGUI_TabControl_getTabTextPadding00);
   tolua_function(tolua_S,"setTabHeight",tolua_CEGUI_CEGUI_TabControl_setTabHeight00);
   tolua_function(tolua_S,"setTabTextPadding",tolua_CEGUI_CEGUI_TabControl_setTabTextPadding00);
   tolua_function(tolua_S,"addTab",tolua_CEGUI_CEGUI_TabControl_addTab00);
   tolua_function(tolua_S,"removeTab",tolua_CEGUI_CEGUI_TabControl_removeTab00);
   tolua_function(tolua_S,"removeTab",tolua_CEGUI_CEGUI_TabControl_removeTab01);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Titlebar","CEGUI::Titlebar","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"Titlebar");
   tolua_function(tolua_S,"isDraggingEnabled",tolua_CEGUI_CEGUI_Titlebar_isDraggingEnabled00);
   tolua_function(tolua_S,"setDraggingEnabled",tolua_CEGUI_CEGUI_Titlebar_setDraggingEnabled00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"TreeItem","CEGUI::TreeItem","",NULL);
  tolua_beginmodule(tolua_S,"TreeItem");
   tolua_function(tolua_S,"getFont",tolua_CEGUI_CEGUI_TreeItem_getFont00);
   tolua_function(tolua_S,"getTextColours",tolua_CEGUI_CEGUI_TreeItem_getTextColours00);
   tolua_function(tolua_S,"setFont",tolua_CEGUI_CEGUI_TreeItem_setFont00);
   tolua_function(tolua_S,"setFont",tolua_CEGUI_CEGUI_TreeItem_setFont01);
   tolua_function(tolua_S,"setTextColours",tolua_CEGUI_CEGUI_TreeItem_setTextColours00);
   tolua_function(tolua_S,"setTextColours",tolua_CEGUI_CEGUI_TreeItem_setTextColours01);
   tolua_function(tolua_S,"setTextColours",tolua_CEGUI_CEGUI_TreeItem_setTextColours02);
   tolua_function(tolua_S,"getText",tolua_CEGUI_CEGUI_TreeItem_getText00);
   tolua_function(tolua_S,"getTooltipText",tolua_CEGUI_CEGUI_TreeItem_getTooltipText00);
   tolua_function(tolua_S,"getID",tolua_CEGUI_CEGUI_TreeItem_getID00);
   tolua_function(tolua_S,"getUserData",tolua_CEGUI_CEGUI_TreeItem_getUserData00);
   tolua_function(tolua_S,"isSelected",tolua_CEGUI_CEGUI_TreeItem_isSelected00);
   tolua_function(tolua_S,"isDisabled",tolua_CEGUI_CEGUI_TreeItem_isDisabled00);
   tolua_function(tolua_S,"isAutoDeleted",tolua_CEGUI_CEGUI_TreeItem_isAutoDeleted00);
   tolua_function(tolua_S,"getOwnerWindow",tolua_CEGUI_CEGUI_TreeItem_getOwnerWindow00);
   tolua_function(tolua_S,"getSelectionColours",tolua_CEGUI_CEGUI_TreeItem_getSelectionColours00);
   tolua_function(tolua_S,"getSelectionBrushImage",tolua_CEGUI_CEGUI_TreeItem_getSelectionBrushImage00);
   tolua_function(tolua_S,"setText",tolua_CEGUI_CEGUI_TreeItem_setText00);
   tolua_function(tolua_S,"setTooltipText",tolua_CEGUI_CEGUI_TreeItem_setTooltipText00);
   tolua_function(tolua_S,"setID",tolua_CEGUI_CEGUI_TreeItem_setID00);
   tolua_function(tolua_S,"setUserData",tolua_CEGUI_CEGUI_TreeItem_setUserData00);
   tolua_function(tolua_S,"setSelected",tolua_CEGUI_CEGUI_TreeItem_setSelected00);
   tolua_function(tolua_S,"setDisabled",tolua_CEGUI_CEGUI_TreeItem_setDisabled00);
   tolua_function(tolua_S,"setAutoDeleted",tolua_CEGUI_CEGUI_TreeItem_setAutoDeleted00);
   tolua_function(tolua_S,"setOwnerWindow",tolua_CEGUI_CEGUI_TreeItem_setOwnerWindow00);
   tolua_function(tolua_S,"setSelectionColours",tolua_CEGUI_CEGUI_TreeItem_setSelectionColours00);
   tolua_function(tolua_S,"setSelectionColours",tolua_CEGUI_CEGUI_TreeItem_setSelectionColours01);
   tolua_function(tolua_S,"setSelectionColours",tolua_CEGUI_CEGUI_TreeItem_setSelectionColours02);
   tolua_function(tolua_S,"setSelectionBrushImage",tolua_CEGUI_CEGUI_TreeItem_setSelectionBrushImage00);
   tolua_function(tolua_S,"setSelectionBrushImage",tolua_CEGUI_CEGUI_TreeItem_setSelectionBrushImage01);
   tolua_function(tolua_S,"setButtonLocation",tolua_CEGUI_CEGUI_TreeItem_setButtonLocation00);
   tolua_function(tolua_S,"getButtonLocation",tolua_CEGUI_CEGUI_TreeItem_getButtonLocation00);
   tolua_function(tolua_S,"getIsOpen",tolua_CEGUI_CEGUI_TreeItem_getIsOpen00);
   tolua_function(tolua_S,"toggleIsOpen",tolua_CEGUI_CEGUI_TreeItem_toggleIsOpen00);
   tolua_function(tolua_S,"getTreeItemFromIndex",tolua_CEGUI_CEGUI_TreeItem_getTreeItemFromIndex00);
   tolua_function(tolua_S,"getItemCount",tolua_CEGUI_CEGUI_TreeItem_getItemCount00);
   tolua_function(tolua_S,"addItem",tolua_CEGUI_CEGUI_TreeItem_addItem00);
   tolua_function(tolua_S,"removeItem",tolua_CEGUI_CEGUI_TreeItem_removeItem00);
   tolua_function(tolua_S,"setIcon",tolua_CEGUI_CEGUI_TreeItem_setIcon00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"FrameWindow","CEGUI::FrameWindow","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"FrameWindow");
   tolua_function(tolua_S,"isSizingEnabled",tolua_CEGUI_CEGUI_FrameWindow_isSizingEnabled00);
   tolua_function(tolua_S,"isFrameEnabled",tolua_CEGUI_CEGUI_FrameWindow_isFrameEnabled00);
   tolua_function(tolua_S,"isTitleBarEnabled",tolua_CEGUI_CEGUI_FrameWindow_isTitleBarEnabled00);
   tolua_function(tolua_S,"isCloseButtonEnabled",tolua_CEGUI_CEGUI_FrameWindow_isCloseButtonEnabled00);
   tolua_function(tolua_S,"isRollupEnabled",tolua_CEGUI_CEGUI_FrameWindow_isRollupEnabled00);
   tolua_function(tolua_S,"isRolledup",tolua_CEGUI_CEGUI_FrameWindow_isRolledup00);
   tolua_function(tolua_S,"isDragMovingEnabled",tolua_CEGUI_CEGUI_FrameWindow_isDragMovingEnabled00);
   tolua_function(tolua_S,"setSizingEnabled",tolua_CEGUI_CEGUI_FrameWindow_setSizingEnabled00);
   tolua_function(tolua_S,"setFrameEnabled",tolua_CEGUI_CEGUI_FrameWindow_setFrameEnabled00);
   tolua_function(tolua_S,"setTitleBarEnabled",tolua_CEGUI_CEGUI_FrameWindow_setTitleBarEnabled00);
   tolua_function(tolua_S,"setCloseButtonEnabled",tolua_CEGUI_CEGUI_FrameWindow_setCloseButtonEnabled00);
   tolua_function(tolua_S,"setRollupEnabled",tolua_CEGUI_CEGUI_FrameWindow_setRollupEnabled00);
   tolua_function(tolua_S,"setDragMovingEnabled",tolua_CEGUI_CEGUI_FrameWindow_setDragMovingEnabled00);
   tolua_function(tolua_S,"getSizingBorderThickness",tolua_CEGUI_CEGUI_FrameWindow_getSizingBorderThickness00);
   tolua_function(tolua_S,"setSizingBorderThickness",tolua_CEGUI_CEGUI_FrameWindow_setSizingBorderThickness00);
   tolua_function(tolua_S,"toggleRollup",tolua_CEGUI_CEGUI_FrameWindow_toggleRollup00);
   tolua_function(tolua_S,"offsetPixelPosition",tolua_CEGUI_CEGUI_FrameWindow_offsetPixelPosition00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Tooltip","CEGUI::Tooltip","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"Tooltip");
   tolua_function(tolua_S,"setTargetWindow",tolua_CEGUI_CEGUI_Tooltip_setTargetWindow00);
   tolua_function(tolua_S,"resetTimer",tolua_CEGUI_CEGUI_Tooltip_resetTimer00);
   tolua_function(tolua_S,"getHoverTime",tolua_CEGUI_CEGUI_Tooltip_getHoverTime00);
   tolua_function(tolua_S,"setDisplayTime",tolua_CEGUI_CEGUI_Tooltip_setDisplayTime00);
   tolua_function(tolua_S,"getFadeTime",tolua_CEGUI_CEGUI_Tooltip_getFadeTime00);
   tolua_function(tolua_S,"setHoverTime",tolua_CEGUI_CEGUI_Tooltip_setHoverTime00);
   tolua_function(tolua_S,"getDisplayTime",tolua_CEGUI_CEGUI_Tooltip_getDisplayTime00);
   tolua_function(tolua_S,"setFadeTime",tolua_CEGUI_CEGUI_Tooltip_setFadeTime00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"DragContainer","CEGUI::DragContainer","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"DragContainer");
   tolua_function(tolua_S,"isDraggingEnabled",tolua_CEGUI_CEGUI_DragContainer_isDraggingEnabled00);
   tolua_function(tolua_S,"setDraggingEnabled",tolua_CEGUI_CEGUI_DragContainer_setDraggingEnabled00);
   tolua_function(tolua_S,"isBeingDragged",tolua_CEGUI_CEGUI_DragContainer_isBeingDragged00);
   tolua_function(tolua_S,"getPixelDragThreshold",tolua_CEGUI_CEGUI_DragContainer_getPixelDragThreshold00);
   tolua_function(tolua_S,"setPixelDragThreshold",tolua_CEGUI_CEGUI_DragContainer_setPixelDragThreshold00);
   tolua_function(tolua_S,"getDragAlpha",tolua_CEGUI_CEGUI_DragContainer_getDragAlpha00);
   tolua_function(tolua_S,"setDragAlpha",tolua_CEGUI_CEGUI_DragContainer_setDragAlpha00);
   tolua_function(tolua_S,"getDragCursorImage",tolua_CEGUI_CEGUI_DragContainer_getDragCursorImage00);
   tolua_function(tolua_S,"setDragCursorImage",tolua_CEGUI_CEGUI_DragContainer_setDragCursorImage00);
   tolua_function(tolua_S,"setDragCursorImage",tolua_CEGUI_CEGUI_DragContainer_setDragCursorImage01);
   tolua_function(tolua_S,"setDragCursorImage",tolua_CEGUI_CEGUI_DragContainer_setDragCursorImage02);
   tolua_function(tolua_S,"getCurrentDropTarget",tolua_CEGUI_CEGUI_DragContainer_getCurrentDropTarget00);
   tolua_function(tolua_S,"isStickyModeEnabled",tolua_CEGUI_CEGUI_DragContainer_isStickyModeEnabled00);
   tolua_function(tolua_S,"setStickyModeEnabled",tolua_CEGUI_CEGUI_DragContainer_setStickyModeEnabled00);
   tolua_function(tolua_S,"pickUp",tolua_CEGUI_CEGUI_DragContainer_pickUp00);
   tolua_function(tolua_S,"setFixedDragOffset",tolua_CEGUI_CEGUI_DragContainer_setFixedDragOffset00);
   tolua_function(tolua_S,"getFixedDragOffset",tolua_CEGUI_CEGUI_DragContainer_getFixedDragOffset00);
   tolua_function(tolua_S,"setUsingFixedDragOffset",tolua_CEGUI_CEGUI_DragContainer_setUsingFixedDragOffset00);
   tolua_function(tolua_S,"isUsingFixedDragOffset",tolua_CEGUI_CEGUI_DragContainer_isUsingFixedDragOffset00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Scrollbar","CEGUI::Scrollbar","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"Scrollbar");
   tolua_function(tolua_S,"getDocumentSize",tolua_CEGUI_CEGUI_Scrollbar_getDocumentSize00);
   tolua_function(tolua_S,"getPageSize",tolua_CEGUI_CEGUI_Scrollbar_getPageSize00);
   tolua_function(tolua_S,"getStepSize",tolua_CEGUI_CEGUI_Scrollbar_getStepSize00);
   tolua_function(tolua_S,"getOverlapSize",tolua_CEGUI_CEGUI_Scrollbar_getOverlapSize00);
   tolua_function(tolua_S,"getScrollPosition",tolua_CEGUI_CEGUI_Scrollbar_getScrollPosition00);
   tolua_function(tolua_S,"isEndLockEnabled",tolua_CEGUI_CEGUI_Scrollbar_isEndLockEnabled00);
   tolua_function(tolua_S,"setDocumentSize",tolua_CEGUI_CEGUI_Scrollbar_setDocumentSize00);
   tolua_function(tolua_S,"setPageSize",tolua_CEGUI_CEGUI_Scrollbar_setPageSize00);
   tolua_function(tolua_S,"setStepSize",tolua_CEGUI_CEGUI_Scrollbar_setStepSize00);
   tolua_function(tolua_S,"setOverlapSize",tolua_CEGUI_CEGUI_Scrollbar_setOverlapSize00);
   tolua_function(tolua_S,"setScrollPosition",tolua_CEGUI_CEGUI_Scrollbar_setScrollPosition00);
   tolua_function(tolua_S,"setEndLockEnabled",tolua_CEGUI_CEGUI_Scrollbar_setEndLockEnabled00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ScrolledContainer","CEGUI::ScrolledContainer","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"ScrolledContainer");
   tolua_function(tolua_S,"isContentPaneAutoSized",tolua_CEGUI_CEGUI_ScrolledContainer_isContentPaneAutoSized00);
   tolua_function(tolua_S,"setContentPaneAutoSized",tolua_CEGUI_CEGUI_ScrolledContainer_setContentPaneAutoSized00);
   tolua_function(tolua_S,"getContentArea",tolua_CEGUI_CEGUI_ScrolledContainer_getContentArea00);
   tolua_function(tolua_S,"setContentArea",tolua_CEGUI_CEGUI_ScrolledContainer_setContentArea00);
   tolua_function(tolua_S,"getChildExtentsArea",tolua_CEGUI_CEGUI_ScrolledContainer_getChildExtentsArea00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ScrollablePane","CEGUI::ScrollablePane","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"ScrollablePane");
   tolua_function(tolua_S,"getContentPane",tolua_CEGUI_CEGUI_ScrollablePane_getContentPane00);
   tolua_function(tolua_S,"isVertScrollbarAlwaysShown",tolua_CEGUI_CEGUI_ScrollablePane_isVertScrollbarAlwaysShown00);
   tolua_function(tolua_S,"setShowVertScrollbar",tolua_CEGUI_CEGUI_ScrollablePane_setShowVertScrollbar00);
   tolua_function(tolua_S,"isHorzScrollbarAlwaysShown",tolua_CEGUI_CEGUI_ScrollablePane_isHorzScrollbarAlwaysShown00);
   tolua_function(tolua_S,"setShowHorzScrollbar",tolua_CEGUI_CEGUI_ScrollablePane_setShowHorzScrollbar00);
   tolua_function(tolua_S,"isContentPaneAutoSized",tolua_CEGUI_CEGUI_ScrollablePane_isContentPaneAutoSized00);
   tolua_function(tolua_S,"setContentPaneAutoSized",tolua_CEGUI_CEGUI_ScrollablePane_setContentPaneAutoSized00);
   tolua_function(tolua_S,"getContentPaneArea",tolua_CEGUI_CEGUI_ScrollablePane_getContentPaneArea00);
   tolua_function(tolua_S,"setContentPaneArea",tolua_CEGUI_CEGUI_ScrollablePane_setContentPaneArea00);
   tolua_function(tolua_S,"getHorizontalStepSize",tolua_CEGUI_CEGUI_ScrollablePane_getHorizontalStepSize00);
   tolua_function(tolua_S,"setHorizontalStepSize",tolua_CEGUI_CEGUI_ScrollablePane_setHorizontalStepSize00);
   tolua_function(tolua_S,"getHorizontalOverlapSize",tolua_CEGUI_CEGUI_ScrollablePane_getHorizontalOverlapSize00);
   tolua_function(tolua_S,"setHorizontalOverlapSize",tolua_CEGUI_CEGUI_ScrollablePane_setHorizontalOverlapSize00);
   tolua_function(tolua_S,"getHorizontalScrollPosition",tolua_CEGUI_CEGUI_ScrollablePane_getHorizontalScrollPosition00);
   tolua_function(tolua_S,"setHorizontalScrollPosition",tolua_CEGUI_CEGUI_ScrollablePane_setHorizontalScrollPosition00);
   tolua_function(tolua_S,"getVerticalStepSize",tolua_CEGUI_CEGUI_ScrollablePane_getVerticalStepSize00);
   tolua_function(tolua_S,"setVerticalStepSize",tolua_CEGUI_CEGUI_ScrollablePane_setVerticalStepSize00);
   tolua_function(tolua_S,"getVerticalOverlapSize",tolua_CEGUI_CEGUI_ScrollablePane_getVerticalOverlapSize00);
   tolua_function(tolua_S,"setVerticalOverlapSize",tolua_CEGUI_CEGUI_ScrollablePane_setVerticalOverlapSize00);
   tolua_function(tolua_S,"getVerticalScrollPosition",tolua_CEGUI_CEGUI_ScrollablePane_getVerticalScrollPosition00);
   tolua_function(tolua_S,"setVerticalScrollPosition",tolua_CEGUI_CEGUI_ScrollablePane_setVerticalScrollPosition00);
   tolua_function(tolua_S,"getViewableArea",tolua_CEGUI_CEGUI_ScrollablePane_getViewableArea00);
   tolua_function(tolua_S,"getVertScrollbar",tolua_CEGUI_CEGUI_ScrollablePane_getVertScrollbar00);
   tolua_function(tolua_S,"getHorzScrollbar",tolua_CEGUI_CEGUI_ScrollablePane_getHorzScrollbar00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Slider","CEGUI::Slider","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"Slider");
   tolua_function(tolua_S,"getCurrentValue",tolua_CEGUI_CEGUI_Slider_getCurrentValue00);
   tolua_function(tolua_S,"getMaxValue",tolua_CEGUI_CEGUI_Slider_getMaxValue00);
   tolua_function(tolua_S,"getClickStep",tolua_CEGUI_CEGUI_Slider_getClickStep00);
   tolua_function(tolua_S,"setMaxValue",tolua_CEGUI_CEGUI_Slider_setMaxValue00);
   tolua_function(tolua_S,"setCurrentValue",tolua_CEGUI_CEGUI_Slider_setCurrentValue00);
   tolua_function(tolua_S,"setClickStep",tolua_CEGUI_CEGUI_Slider_setClickStep00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Spinner","CEGUI::Spinner","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"Spinner");
   tolua_constant(tolua_S,"FloatingPoint",CEGUI::Spinner::FloatingPoint);
   tolua_constant(tolua_S,"Integer",CEGUI::Spinner::Integer);
   tolua_constant(tolua_S,"Hexadecimal",CEGUI::Spinner::Hexadecimal);
   tolua_constant(tolua_S,"Octal",CEGUI::Spinner::Octal);
   tolua_function(tolua_S,"getCurrentValue",tolua_CEGUI_CEGUI_Spinner_getCurrentValue00);
   tolua_function(tolua_S,"getStepSize",tolua_CEGUI_CEGUI_Spinner_getStepSize00);
   tolua_function(tolua_S,"getMaximumValue",tolua_CEGUI_CEGUI_Spinner_getMaximumValue00);
   tolua_function(tolua_S,"getMinimumValue",tolua_CEGUI_CEGUI_Spinner_getMinimumValue00);
   tolua_function(tolua_S,"getTextInputMode",tolua_CEGUI_CEGUI_Spinner_getTextInputMode00);
   tolua_function(tolua_S,"setCurrentValue",tolua_CEGUI_CEGUI_Spinner_setCurrentValue00);
   tolua_function(tolua_S,"setStepSize",tolua_CEGUI_CEGUI_Spinner_setStepSize00);
   tolua_function(tolua_S,"setMaximumValue",tolua_CEGUI_CEGUI_Spinner_setMaximumValue00);
   tolua_function(tolua_S,"setMinimumValue",tolua_CEGUI_CEGUI_Spinner_setMinimumValue00);
   tolua_function(tolua_S,"setTextInputMode",tolua_CEGUI_CEGUI_Spinner_setTextInputMode00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ProgressBar","CEGUI::ProgressBar","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"ProgressBar");
   tolua_function(tolua_S,"getProgress",tolua_CEGUI_CEGUI_ProgressBar_getProgress00);
   tolua_function(tolua_S,"getStep",tolua_CEGUI_CEGUI_ProgressBar_getStep00);
   tolua_function(tolua_S,"setProgress",tolua_CEGUI_CEGUI_ProgressBar_setProgress00);
   tolua_function(tolua_S,"setStepSize",tolua_CEGUI_CEGUI_ProgressBar_setStepSize00);
   tolua_function(tolua_S,"step",tolua_CEGUI_CEGUI_ProgressBar_step00);
   tolua_function(tolua_S,"adjustProgress",tolua_CEGUI_CEGUI_ProgressBar_adjustProgress00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Editbox","CEGUI::Editbox","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"Editbox");
   tolua_function(tolua_S,"hasInputFocus",tolua_CEGUI_CEGUI_Editbox_hasInputFocus00);
   tolua_function(tolua_S,"isReadOnly",tolua_CEGUI_CEGUI_Editbox_isReadOnly00);
   tolua_function(tolua_S,"isTextMasked",tolua_CEGUI_CEGUI_Editbox_isTextMasked00);
   tolua_function(tolua_S,"isTextValid",tolua_CEGUI_CEGUI_Editbox_isTextValid00);
   tolua_function(tolua_S,"getValidationString",tolua_CEGUI_CEGUI_Editbox_getValidationString00);
   tolua_function(tolua_S,"getCaratIndex",tolua_CEGUI_CEGUI_Editbox_getCaratIndex00);
   tolua_function(tolua_S,"getSelectionStartIndex",tolua_CEGUI_CEGUI_Editbox_getSelectionStartIndex00);
   tolua_function(tolua_S,"getSelectionEndIndex",tolua_CEGUI_CEGUI_Editbox_getSelectionEndIndex00);
   tolua_function(tolua_S,"getSelectionLength",tolua_CEGUI_CEGUI_Editbox_getSelectionLength00);
   tolua_function(tolua_S,"getMaskCodePoint",tolua_CEGUI_CEGUI_Editbox_getMaskCodePoint00);
   tolua_function(tolua_S,"getMaxTextLength",tolua_CEGUI_CEGUI_Editbox_getMaxTextLength00);
   tolua_function(tolua_S,"setReadOnly",tolua_CEGUI_CEGUI_Editbox_setReadOnly00);
   tolua_function(tolua_S,"setTextMasked",tolua_CEGUI_CEGUI_Editbox_setTextMasked00);
   tolua_function(tolua_S,"setValidationString",tolua_CEGUI_CEGUI_Editbox_setValidationString00);
   tolua_function(tolua_S,"setCaratIndex",tolua_CEGUI_CEGUI_Editbox_setCaratIndex00);
   tolua_function(tolua_S,"setSelection",tolua_CEGUI_CEGUI_Editbox_setSelection00);
   tolua_function(tolua_S,"setMaskCodePoint",tolua_CEGUI_CEGUI_Editbox_setMaskCodePoint00);
   tolua_function(tolua_S,"setMaxTextLength",tolua_CEGUI_CEGUI_Editbox_setMaxTextLength00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"MultiLineEditbox","CEGUI::MultiLineEditbox","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"MultiLineEditbox");
   tolua_function(tolua_S,"hasInputFocus",tolua_CEGUI_CEGUI_MultiLineEditbox_hasInputFocus00);
   tolua_function(tolua_S,"isReadOnly",tolua_CEGUI_CEGUI_MultiLineEditbox_isReadOnly00);
   tolua_function(tolua_S,"getCaratIndex",tolua_CEGUI_CEGUI_MultiLineEditbox_getCaratIndex00);
   tolua_function(tolua_S,"getSelectionStartIndex",tolua_CEGUI_CEGUI_MultiLineEditbox_getSelectionStartIndex00);
   tolua_function(tolua_S,"getSelectionEndIndex",tolua_CEGUI_CEGUI_MultiLineEditbox_getSelectionEndIndex00);
   tolua_function(tolua_S,"getSelectionLength",tolua_CEGUI_CEGUI_MultiLineEditbox_getSelectionLength00);
   tolua_function(tolua_S,"getMaxTextLength",tolua_CEGUI_CEGUI_MultiLineEditbox_getMaxTextLength00);
   tolua_function(tolua_S,"isWordWrapped",tolua_CEGUI_CEGUI_MultiLineEditbox_isWordWrapped00);
   tolua_function(tolua_S,"getVertScrollbar",tolua_CEGUI_CEGUI_MultiLineEditbox_getVertScrollbar00);
   tolua_function(tolua_S,"isVertScrollbarAlwaysShown",tolua_CEGUI_CEGUI_MultiLineEditbox_isVertScrollbarAlwaysShown00);
   tolua_function(tolua_S,"getHorzScrollbar",tolua_CEGUI_CEGUI_MultiLineEditbox_getHorzScrollbar00);
   tolua_function(tolua_S,"getTextRenderArea",tolua_CEGUI_CEGUI_MultiLineEditbox_getTextRenderArea00);
   tolua_function(tolua_S,"getLineNumberFromIndex",tolua_CEGUI_CEGUI_MultiLineEditbox_getLineNumberFromIndex00);
   tolua_function(tolua_S,"setReadOnly",tolua_CEGUI_CEGUI_MultiLineEditbox_setReadOnly00);
   tolua_function(tolua_S,"setCaratIndex",tolua_CEGUI_CEGUI_MultiLineEditbox_setCaratIndex00);
   tolua_function(tolua_S,"setSelection",tolua_CEGUI_CEGUI_MultiLineEditbox_setSelection00);
   tolua_function(tolua_S,"setMaxTextLength",tolua_CEGUI_CEGUI_MultiLineEditbox_setMaxTextLength00);
   tolua_function(tolua_S,"ensureCaratIsVisible",tolua_CEGUI_CEGUI_MultiLineEditbox_ensureCaratIsVisible00);
   tolua_function(tolua_S,"setWordWrapping",tolua_CEGUI_CEGUI_MultiLineEditbox_setWordWrapping00);
   tolua_function(tolua_S,"setShowVertScrollbar",tolua_CEGUI_CEGUI_MultiLineEditbox_setShowVertScrollbar00);
   tolua_function(tolua_S,"setSelectionBrushImage",tolua_CEGUI_CEGUI_MultiLineEditbox_setSelectionBrushImage00);
   tolua_function(tolua_S,"getSelectionBrushImage",tolua_CEGUI_CEGUI_MultiLineEditbox_getSelectionBrushImage00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ListboxItem","CEGUI::ListboxItem","",NULL);
  tolua_beginmodule(tolua_S,"ListboxItem");
   tolua_function(tolua_S,"getText",tolua_CEGUI_CEGUI_ListboxItem_getText00);
   tolua_function(tolua_S,"getID",tolua_CEGUI_CEGUI_ListboxItem_getID00);
   tolua_function(tolua_S,"getUserData",tolua_CEGUI_CEGUI_ListboxItem_getUserData00);
   tolua_function(tolua_S,"isSelected",tolua_CEGUI_CEGUI_ListboxItem_isSelected00);
   tolua_function(tolua_S,"isDisabled",tolua_CEGUI_CEGUI_ListboxItem_isDisabled00);
   tolua_function(tolua_S,"isAutoDeleted",tolua_CEGUI_CEGUI_ListboxItem_isAutoDeleted00);
   tolua_function(tolua_S,"getOwnerWindow",tolua_CEGUI_CEGUI_ListboxItem_getOwnerWindow00);
   tolua_function(tolua_S,"getSelectionColours",tolua_CEGUI_CEGUI_ListboxItem_getSelectionColours00);
   tolua_function(tolua_S,"getSelectionBrushImage",tolua_CEGUI_CEGUI_ListboxItem_getSelectionBrushImage00);
   tolua_function(tolua_S,"setText",tolua_CEGUI_CEGUI_ListboxItem_setText00);
   tolua_function(tolua_S,"setID",tolua_CEGUI_CEGUI_ListboxItem_setID00);
   tolua_function(tolua_S,"setUserData",tolua_CEGUI_CEGUI_ListboxItem_setUserData00);
   tolua_function(tolua_S,"setSelected",tolua_CEGUI_CEGUI_ListboxItem_setSelected00);
   tolua_function(tolua_S,"setDisabled",tolua_CEGUI_CEGUI_ListboxItem_setDisabled00);
   tolua_function(tolua_S,"setAutoDeleted",tolua_CEGUI_CEGUI_ListboxItem_setAutoDeleted00);
   tolua_function(tolua_S,"setOwnerWindow",tolua_CEGUI_CEGUI_ListboxItem_setOwnerWindow00);
   tolua_function(tolua_S,"setSelectionColours",tolua_CEGUI_CEGUI_ListboxItem_setSelectionColours00);
   tolua_function(tolua_S,"setSelectionColours",tolua_CEGUI_CEGUI_ListboxItem_setSelectionColours01);
   tolua_function(tolua_S,"setSelectionColours",tolua_CEGUI_CEGUI_ListboxItem_setSelectionColours02);
   tolua_function(tolua_S,"setSelectionBrushImage",tolua_CEGUI_CEGUI_ListboxItem_setSelectionBrushImage00);
   tolua_function(tolua_S,"setSelectionBrushImage",tolua_CEGUI_CEGUI_ListboxItem_setSelectionBrushImage01);
   tolua_function(tolua_S,"getPixelSize",tolua_CEGUI_CEGUI_ListboxItem_getPixelSize00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ListboxTextItem","CEGUI::ListboxTextItem","CEGUI::ListboxItem",NULL);
  tolua_beginmodule(tolua_S,"ListboxTextItem");
   tolua_function(tolua_S,"getFont",tolua_CEGUI_CEGUI_ListboxTextItem_getFont00);
   tolua_function(tolua_S,"getTextColours",tolua_CEGUI_CEGUI_ListboxTextItem_getTextColours00);
   tolua_function(tolua_S,"setFont",tolua_CEGUI_CEGUI_ListboxTextItem_setFont00);
   tolua_function(tolua_S,"setFont",tolua_CEGUI_CEGUI_ListboxTextItem_setFont01);
   tolua_function(tolua_S,"setTextColours",tolua_CEGUI_CEGUI_ListboxTextItem_setTextColours00);
   tolua_function(tolua_S,"setTextColours",tolua_CEGUI_CEGUI_ListboxTextItem_setTextColours01);
   tolua_function(tolua_S,"setTextColours",tolua_CEGUI_CEGUI_ListboxTextItem_setTextColours02);
   tolua_function(tolua_S,"setTextParsingEnabled",tolua_CEGUI_CEGUI_ListboxTextItem_setTextParsingEnabled00);
   tolua_function(tolua_S,"isTextParsingEnabled",tolua_CEGUI_CEGUI_ListboxTextItem_isTextParsingEnabled00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Combobox","CEGUI::Combobox","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"Combobox");
   tolua_function(tolua_S,"getSingleClickEnabled",tolua_CEGUI_CEGUI_Combobox_getSingleClickEnabled00);
   tolua_function(tolua_S,"isDropDownListVisible",tolua_CEGUI_CEGUI_Combobox_isDropDownListVisible00);
   tolua_function(tolua_S,"getEditbox",tolua_CEGUI_CEGUI_Combobox_getEditbox00);
   tolua_function(tolua_S,"getPushButton",tolua_CEGUI_CEGUI_Combobox_getPushButton00);
   tolua_function(tolua_S,"getDropList",tolua_CEGUI_CEGUI_Combobox_getDropList00);
   tolua_function(tolua_S,"hasInputFocus",tolua_CEGUI_CEGUI_Combobox_hasInputFocus00);
   tolua_function(tolua_S,"isReadOnly",tolua_CEGUI_CEGUI_Combobox_isReadOnly00);
   tolua_function(tolua_S,"isTextValid",tolua_CEGUI_CEGUI_Combobox_isTextValid00);
   tolua_function(tolua_S,"getValidationString",tolua_CEGUI_CEGUI_Combobox_getValidationString00);
   tolua_function(tolua_S,"getCaratIndex",tolua_CEGUI_CEGUI_Combobox_getCaratIndex00);
   tolua_function(tolua_S,"getSelectionStartIndex",tolua_CEGUI_CEGUI_Combobox_getSelectionStartIndex00);
   tolua_function(tolua_S,"getSelectionEndIndex",tolua_CEGUI_CEGUI_Combobox_getSelectionEndIndex00);
   tolua_function(tolua_S,"getSelectionLength",tolua_CEGUI_CEGUI_Combobox_getSelectionLength00);
   tolua_function(tolua_S,"getMaxTextLength",tolua_CEGUI_CEGUI_Combobox_getMaxTextLength00);
   tolua_function(tolua_S,"activateEditbox",tolua_CEGUI_CEGUI_Combobox_activateEditbox00);
   tolua_function(tolua_S,"getItemCount",tolua_CEGUI_CEGUI_Combobox_getItemCount00);
   tolua_function(tolua_S,"getSelectedItem",tolua_CEGUI_CEGUI_Combobox_getSelectedItem00);
   tolua_function(tolua_S,"getListboxItemFromIndex",tolua_CEGUI_CEGUI_Combobox_getListboxItemFromIndex00);
   tolua_function(tolua_S,"getItemIndex",tolua_CEGUI_CEGUI_Combobox_getItemIndex00);
   tolua_function(tolua_S,"isItemSelected",tolua_CEGUI_CEGUI_Combobox_isItemSelected00);
   tolua_function(tolua_S,"findItemWithText",tolua_CEGUI_CEGUI_Combobox_findItemWithText00);
   tolua_function(tolua_S,"isListboxItemInList",tolua_CEGUI_CEGUI_Combobox_isListboxItemInList00);
   tolua_function(tolua_S,"resetList",tolua_CEGUI_CEGUI_Combobox_resetList00);
   tolua_function(tolua_S,"addItem",tolua_CEGUI_CEGUI_Combobox_addItem00);
   tolua_function(tolua_S,"insertItem",tolua_CEGUI_CEGUI_Combobox_insertItem00);
   tolua_function(tolua_S,"removeItem",tolua_CEGUI_CEGUI_Combobox_removeItem00);
   tolua_function(tolua_S,"clearAllSelections",tolua_CEGUI_CEGUI_Combobox_clearAllSelections00);
   tolua_function(tolua_S,"setSortingEnabled",tolua_CEGUI_CEGUI_Combobox_setSortingEnabled00);
   tolua_function(tolua_S,"setShowVertScrollbar",tolua_CEGUI_CEGUI_Combobox_setShowVertScrollbar00);
   tolua_function(tolua_S,"setShowHorzScrollbar",tolua_CEGUI_CEGUI_Combobox_setShowHorzScrollbar00);
   tolua_function(tolua_S,"setItemSelectState",tolua_CEGUI_CEGUI_Combobox_setItemSelectState00);
   tolua_function(tolua_S,"setItemSelectState",tolua_CEGUI_CEGUI_Combobox_setItemSelectState01);
   tolua_function(tolua_S,"handleUpdatedListItemData",tolua_CEGUI_CEGUI_Combobox_handleUpdatedListItemData00);
   tolua_function(tolua_S,"isSortEnabled",tolua_CEGUI_CEGUI_Combobox_isSortEnabled00);
   tolua_function(tolua_S,"isVertScrollbarAlwaysShown",tolua_CEGUI_CEGUI_Combobox_isVertScrollbarAlwaysShown00);
   tolua_function(tolua_S,"isHorzScrollbarAlwaysShown",tolua_CEGUI_CEGUI_Combobox_isHorzScrollbarAlwaysShown00);
   tolua_function(tolua_S,"showDropList",tolua_CEGUI_CEGUI_Combobox_showDropList00);
   tolua_function(tolua_S,"hideDropList",tolua_CEGUI_CEGUI_Combobox_hideDropList00);
   tolua_function(tolua_S,"setSingleClickEnabled",tolua_CEGUI_CEGUI_Combobox_setSingleClickEnabled00);
   tolua_function(tolua_S,"setReadOnly",tolua_CEGUI_CEGUI_Combobox_setReadOnly00);
   tolua_function(tolua_S,"setValidationString",tolua_CEGUI_CEGUI_Combobox_setValidationString00);
   tolua_function(tolua_S,"setCaratIndex",tolua_CEGUI_CEGUI_Combobox_setCaratIndex00);
   tolua_function(tolua_S,"setSelection",tolua_CEGUI_CEGUI_Combobox_setSelection00);
   tolua_function(tolua_S,"setMaxTextLength",tolua_CEGUI_CEGUI_Combobox_setMaxTextLength00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Listbox","CEGUI::Listbox","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"Listbox");
   tolua_function(tolua_S,"getItemCount",tolua_CEGUI_CEGUI_Listbox_getItemCount00);
   tolua_function(tolua_S,"getSelectedCount",tolua_CEGUI_CEGUI_Listbox_getSelectedCount00);
   tolua_function(tolua_S,"getFirstSelectedItem",tolua_CEGUI_CEGUI_Listbox_getFirstSelectedItem00);
   tolua_function(tolua_S,"getNextSelected",tolua_CEGUI_CEGUI_Listbox_getNextSelected00);
   tolua_function(tolua_S,"getListboxItemFromIndex",tolua_CEGUI_CEGUI_Listbox_getListboxItemFromIndex00);
   tolua_function(tolua_S,"getItemIndex",tolua_CEGUI_CEGUI_Listbox_getItemIndex00);
   tolua_function(tolua_S,"findItemWithText",tolua_CEGUI_CEGUI_Listbox_findItemWithText00);
   tolua_function(tolua_S,"isSortEnabled",tolua_CEGUI_CEGUI_Listbox_isSortEnabled00);
   tolua_function(tolua_S,"isMultiselectEnabled",tolua_CEGUI_CEGUI_Listbox_isMultiselectEnabled00);
   tolua_function(tolua_S,"isItemSelected",tolua_CEGUI_CEGUI_Listbox_isItemSelected00);
   tolua_function(tolua_S,"isListboxItemInList",tolua_CEGUI_CEGUI_Listbox_isListboxItemInList00);
   tolua_function(tolua_S,"isVertScrollbarAlwaysShown",tolua_CEGUI_CEGUI_Listbox_isVertScrollbarAlwaysShown00);
   tolua_function(tolua_S,"isHorzScrollbarAlwaysShown",tolua_CEGUI_CEGUI_Listbox_isHorzScrollbarAlwaysShown00);
   tolua_function(tolua_S,"resetList",tolua_CEGUI_CEGUI_Listbox_resetList00);
   tolua_function(tolua_S,"addItem",tolua_CEGUI_CEGUI_Listbox_addItem00);
   tolua_function(tolua_S,"insertItem",tolua_CEGUI_CEGUI_Listbox_insertItem00);
   tolua_function(tolua_S,"removeItem",tolua_CEGUI_CEGUI_Listbox_removeItem00);
   tolua_function(tolua_S,"clearAllSelections",tolua_CEGUI_CEGUI_Listbox_clearAllSelections00);
   tolua_function(tolua_S,"setSortingEnabled",tolua_CEGUI_CEGUI_Listbox_setSortingEnabled00);
   tolua_function(tolua_S,"setMultiselectEnabled",tolua_CEGUI_CEGUI_Listbox_setMultiselectEnabled00);
   tolua_function(tolua_S,"setShowVertScrollbar",tolua_CEGUI_CEGUI_Listbox_setShowVertScrollbar00);
   tolua_function(tolua_S,"setShowHorzScrollbar",tolua_CEGUI_CEGUI_Listbox_setShowHorzScrollbar00);
   tolua_function(tolua_S,"setItemSelectState",tolua_CEGUI_CEGUI_Listbox_setItemSelectState00);
   tolua_function(tolua_S,"setItemSelectState",tolua_CEGUI_CEGUI_Listbox_setItemSelectState01);
   tolua_function(tolua_S,"handleUpdatedItemData",tolua_CEGUI_CEGUI_Listbox_handleUpdatedItemData00);
   tolua_function(tolua_S,"ensureItemIsVisible",tolua_CEGUI_CEGUI_Listbox_ensureItemIsVisible00);
   tolua_function(tolua_S,"ensureItemIsVisible",tolua_CEGUI_CEGUI_Listbox_ensureItemIsVisible01);
   tolua_function(tolua_S,"getListRenderArea",tolua_CEGUI_CEGUI_Listbox_getListRenderArea00);
   tolua_function(tolua_S,"getVertScrollbar",tolua_CEGUI_CEGUI_Listbox_getVertScrollbar00);
   tolua_function(tolua_S,"getHorzScrollbar",tolua_CEGUI_CEGUI_Listbox_getHorzScrollbar00);
   tolua_function(tolua_S,"getWidestItemWidth",tolua_CEGUI_CEGUI_Listbox_getWidestItemWidth00);
   tolua_function(tolua_S,"getTotalItemsHeight",tolua_CEGUI_CEGUI_Listbox_getTotalItemsHeight00);
   tolua_function(tolua_S,"getItemAtPoint",tolua_CEGUI_CEGUI_Listbox_getItemAtPoint00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ComboDropList","CEGUI::ComboDropList","CEGUI::Listbox",NULL);
  tolua_beginmodule(tolua_S,"ComboDropList");
   tolua_function(tolua_S,"setArmed",tolua_CEGUI_CEGUI_ComboDropList_setArmed00);
   tolua_function(tolua_S,"isArmed",tolua_CEGUI_CEGUI_ComboDropList_isArmed00);
   tolua_function(tolua_S,"setAutoArmEnabled",tolua_CEGUI_CEGUI_ComboDropList_setAutoArmEnabled00);
   tolua_function(tolua_S,"isAutoArmEnabled",tolua_CEGUI_CEGUI_ComboDropList_isAutoArmEnabled00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ListHeaderSegment","CEGUI::ListHeaderSegment","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"ListHeaderSegment");
   tolua_constant(tolua_S,"None",CEGUI::ListHeaderSegment::None);
   tolua_constant(tolua_S,"Ascending",CEGUI::ListHeaderSegment::Ascending);
   tolua_constant(tolua_S,"Descending",CEGUI::ListHeaderSegment::Descending);
   tolua_function(tolua_S,"isSizingEnabled",tolua_CEGUI_CEGUI_ListHeaderSegment_isSizingEnabled00);
   tolua_function(tolua_S,"getSortDirection",tolua_CEGUI_CEGUI_ListHeaderSegment_getSortDirection00);
   tolua_function(tolua_S,"isDragMovingEnabled",tolua_CEGUI_CEGUI_ListHeaderSegment_isDragMovingEnabled00);
   tolua_function(tolua_S,"getDragMoveOffset",tolua_CEGUI_CEGUI_ListHeaderSegment_getDragMoveOffset00);
   tolua_function(tolua_S,"isClickable",tolua_CEGUI_CEGUI_ListHeaderSegment_isClickable00);
   tolua_function(tolua_S,"setSizingEnabled",tolua_CEGUI_CEGUI_ListHeaderSegment_setSizingEnabled00);
   tolua_function(tolua_S,"setSortDirection",tolua_CEGUI_CEGUI_ListHeaderSegment_setSortDirection00);
   tolua_function(tolua_S,"setDragMovingEnabled",tolua_CEGUI_CEGUI_ListHeaderSegment_setDragMovingEnabled00);
   tolua_function(tolua_S,"setClickable",tolua_CEGUI_CEGUI_ListHeaderSegment_setClickable00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ListHeader","CEGUI::ListHeader","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"ListHeader");
   tolua_function(tolua_S,"getColumnCount",tolua_CEGUI_CEGUI_ListHeader_getColumnCount00);
   tolua_function(tolua_S,"getSegmentFromColumn",tolua_CEGUI_CEGUI_ListHeader_getSegmentFromColumn00);
   tolua_function(tolua_S,"getSegmentFromID",tolua_CEGUI_CEGUI_ListHeader_getSegmentFromID00);
   tolua_function(tolua_S,"getSortSegment",tolua_CEGUI_CEGUI_ListHeader_getSortSegment00);
   tolua_function(tolua_S,"getColumnFromSegment",tolua_CEGUI_CEGUI_ListHeader_getColumnFromSegment00);
   tolua_function(tolua_S,"getColumnFromID",tolua_CEGUI_CEGUI_ListHeader_getColumnFromID00);
   tolua_function(tolua_S,"getSortColumn",tolua_CEGUI_CEGUI_ListHeader_getSortColumn00);
   tolua_function(tolua_S,"getColumnWithText",tolua_CEGUI_CEGUI_ListHeader_getColumnWithText00);
   tolua_function(tolua_S,"getPixelOffsetToSegment",tolua_CEGUI_CEGUI_ListHeader_getPixelOffsetToSegment00);
   tolua_function(tolua_S,"getPixelOffsetToColumn",tolua_CEGUI_CEGUI_ListHeader_getPixelOffsetToColumn00);
   tolua_function(tolua_S,"getTotalSegmentsPixelExtent",tolua_CEGUI_CEGUI_ListHeader_getTotalSegmentsPixelExtent00);
   tolua_function(tolua_S,"getColumnWidth",tolua_CEGUI_CEGUI_ListHeader_getColumnWidth00);
   tolua_function(tolua_S,"getSortDirection",tolua_CEGUI_CEGUI_ListHeader_getSortDirection00);
   tolua_function(tolua_S,"isSortingEnabled",tolua_CEGUI_CEGUI_ListHeader_isSortingEnabled00);
   tolua_function(tolua_S,"isColumnSizingEnabled",tolua_CEGUI_CEGUI_ListHeader_isColumnSizingEnabled00);
   tolua_function(tolua_S,"isColumnDraggingEnabled",tolua_CEGUI_CEGUI_ListHeader_isColumnDraggingEnabled00);
   tolua_function(tolua_S,"getSegmentOffset",tolua_CEGUI_CEGUI_ListHeader_getSegmentOffset00);
   tolua_function(tolua_S,"setSortingEnabled",tolua_CEGUI_CEGUI_ListHeader_setSortingEnabled00);
   tolua_function(tolua_S,"setSortDirection",tolua_CEGUI_CEGUI_ListHeader_setSortDirection00);
   tolua_function(tolua_S,"setSortSegment",tolua_CEGUI_CEGUI_ListHeader_setSortSegment00);
   tolua_function(tolua_S,"setSortColumn",tolua_CEGUI_CEGUI_ListHeader_setSortColumn00);
   tolua_function(tolua_S,"setSortColumnFromID",tolua_CEGUI_CEGUI_ListHeader_setSortColumnFromID00);
   tolua_function(tolua_S,"setColumnSizingEnabled",tolua_CEGUI_CEGUI_ListHeader_setColumnSizingEnabled00);
   tolua_function(tolua_S,"setColumnDraggingEnabled",tolua_CEGUI_CEGUI_ListHeader_setColumnDraggingEnabled00);
   tolua_function(tolua_S,"addColumn",tolua_CEGUI_CEGUI_ListHeader_addColumn00);
   tolua_function(tolua_S,"insertColumn",tolua_CEGUI_CEGUI_ListHeader_insertColumn00);
   tolua_function(tolua_S,"insertColumn",tolua_CEGUI_CEGUI_ListHeader_insertColumn01);
   tolua_function(tolua_S,"removeColumn",tolua_CEGUI_CEGUI_ListHeader_removeColumn00);
   tolua_function(tolua_S,"removeSegment",tolua_CEGUI_CEGUI_ListHeader_removeSegment00);
   tolua_function(tolua_S,"moveColumn",tolua_CEGUI_CEGUI_ListHeader_moveColumn00);
   tolua_function(tolua_S,"moveColumn",tolua_CEGUI_CEGUI_ListHeader_moveColumn01);
   tolua_function(tolua_S,"moveSegment",tolua_CEGUI_CEGUI_ListHeader_moveSegment00);
   tolua_function(tolua_S,"moveSegment",tolua_CEGUI_CEGUI_ListHeader_moveSegment01);
   tolua_function(tolua_S,"setSegmentOffset",tolua_CEGUI_CEGUI_ListHeader_setSegmentOffset00);
   tolua_function(tolua_S,"setColumnWidth",tolua_CEGUI_CEGUI_ListHeader_setColumnWidth00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"MCLGridRef","CEGUI::MCLGridRef","",tolua_collect_CEGUI__MCLGridRef);
  #else
  tolua_cclass(tolua_S,"MCLGridRef","CEGUI::MCLGridRef","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"MCLGridRef");
   tolua_variable(tolua_S,"row",tolua_get_CEGUI__MCLGridRef_unsigned_row,tolua_set_CEGUI__MCLGridRef_unsigned_row);
   tolua_variable(tolua_S,"column",tolua_get_CEGUI__MCLGridRef_unsigned_column,tolua_set_CEGUI__MCLGridRef_unsigned_column);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_MCLGridRef__eq00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_MCLGridRef_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_MCLGridRef_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_MCLGridRef_new00_local);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"MultiColumnList","CEGUI::MultiColumnList","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"MultiColumnList");
   tolua_constant(tolua_S,"RowSingle",CEGUI::MultiColumnList::RowSingle);
   tolua_constant(tolua_S,"RowMultiple",CEGUI::MultiColumnList::RowMultiple);
   tolua_constant(tolua_S,"CellSingle",CEGUI::MultiColumnList::CellSingle);
   tolua_constant(tolua_S,"CellMultiple",CEGUI::MultiColumnList::CellMultiple);
   tolua_constant(tolua_S,"NominatedColumnSingle",CEGUI::MultiColumnList::NominatedColumnSingle);
   tolua_constant(tolua_S,"NominatedColumnMultiple",CEGUI::MultiColumnList::NominatedColumnMultiple);
   tolua_constant(tolua_S,"ColumnSingle",CEGUI::MultiColumnList::ColumnSingle);
   tolua_constant(tolua_S,"ColumnMultiple",CEGUI::MultiColumnList::ColumnMultiple);
   tolua_constant(tolua_S,"NominatedRowSingle",CEGUI::MultiColumnList::NominatedRowSingle);
   tolua_constant(tolua_S,"NominatedRowMultiple",CEGUI::MultiColumnList::NominatedRowMultiple);
   tolua_function(tolua_S,"isUserSortControlEnabled",tolua_CEGUI_CEGUI_MultiColumnList_isUserSortControlEnabled00);
   tolua_function(tolua_S,"isUserColumnSizingEnabled",tolua_CEGUI_CEGUI_MultiColumnList_isUserColumnSizingEnabled00);
   tolua_function(tolua_S,"isUserColumnDraggingEnabled",tolua_CEGUI_CEGUI_MultiColumnList_isUserColumnDraggingEnabled00);
   tolua_function(tolua_S,"getColumnCount",tolua_CEGUI_CEGUI_MultiColumnList_getColumnCount00);
   tolua_function(tolua_S,"getRowCount",tolua_CEGUI_CEGUI_MultiColumnList_getRowCount00);
   tolua_function(tolua_S,"getSortColumn",tolua_CEGUI_CEGUI_MultiColumnList_getSortColumn00);
   tolua_function(tolua_S,"getColumnWithID",tolua_CEGUI_CEGUI_MultiColumnList_getColumnWithID00);
   tolua_function(tolua_S,"getColumnWithHeaderText",tolua_CEGUI_CEGUI_MultiColumnList_getColumnWithHeaderText00);
   tolua_function(tolua_S,"getTotalColumnHeadersWidth",tolua_CEGUI_CEGUI_MultiColumnList_getTotalColumnHeadersWidth00);
   tolua_function(tolua_S,"getColumnHeaderWidth",tolua_CEGUI_CEGUI_MultiColumnList_getColumnHeaderWidth00);
   tolua_function(tolua_S,"getSortDirection",tolua_CEGUI_CEGUI_MultiColumnList_getSortDirection00);
   tolua_function(tolua_S,"getHeaderSegmentForColumn",tolua_CEGUI_CEGUI_MultiColumnList_getHeaderSegmentForColumn00);
   tolua_function(tolua_S,"getItemRowIndex",tolua_CEGUI_CEGUI_MultiColumnList_getItemRowIndex00);
   tolua_function(tolua_S,"getItemColumnIndex",tolua_CEGUI_CEGUI_MultiColumnList_getItemColumnIndex00);
   tolua_function(tolua_S,"getItemGridReference",tolua_CEGUI_CEGUI_MultiColumnList_getItemGridReference00);
   tolua_function(tolua_S,"getItemAtGridReference",tolua_CEGUI_CEGUI_MultiColumnList_getItemAtGridReference00);
   tolua_function(tolua_S,"isListboxItemInColumn",tolua_CEGUI_CEGUI_MultiColumnList_isListboxItemInColumn00);
   tolua_function(tolua_S,"isListboxItemInRow",tolua_CEGUI_CEGUI_MultiColumnList_isListboxItemInRow00);
   tolua_function(tolua_S,"isListboxItemInList",tolua_CEGUI_CEGUI_MultiColumnList_isListboxItemInList00);
   tolua_function(tolua_S,"findColumnItemWithText",tolua_CEGUI_CEGUI_MultiColumnList_findColumnItemWithText00);
   tolua_function(tolua_S,"findRowItemWithText",tolua_CEGUI_CEGUI_MultiColumnList_findRowItemWithText00);
   tolua_function(tolua_S,"findListItemWithText",tolua_CEGUI_CEGUI_MultiColumnList_findListItemWithText00);
   tolua_function(tolua_S,"getFirstSelectedItem",tolua_CEGUI_CEGUI_MultiColumnList_getFirstSelectedItem00);
   tolua_function(tolua_S,"getNextSelected",tolua_CEGUI_CEGUI_MultiColumnList_getNextSelected00);
   tolua_function(tolua_S,"getSelectedCount",tolua_CEGUI_CEGUI_MultiColumnList_getSelectedCount00);
   tolua_function(tolua_S,"isItemSelected",tolua_CEGUI_CEGUI_MultiColumnList_isItemSelected00);
   tolua_function(tolua_S,"getNominatedSelectionColumnID",tolua_CEGUI_CEGUI_MultiColumnList_getNominatedSelectionColumnID00);
   tolua_function(tolua_S,"getNominatedSelectionColumn",tolua_CEGUI_CEGUI_MultiColumnList_getNominatedSelectionColumn00);
   tolua_function(tolua_S,"getNominatedSelectionRow",tolua_CEGUI_CEGUI_MultiColumnList_getNominatedSelectionRow00);
   tolua_function(tolua_S,"getSelectionMode",tolua_CEGUI_CEGUI_MultiColumnList_getSelectionMode00);
   tolua_function(tolua_S,"isVertScrollbarAlwaysShown",tolua_CEGUI_CEGUI_MultiColumnList_isVertScrollbarAlwaysShown00);
   tolua_function(tolua_S,"isHorzScrollbarAlwaysShown",tolua_CEGUI_CEGUI_MultiColumnList_isHorzScrollbarAlwaysShown00);
   tolua_function(tolua_S,"getColumnID",tolua_CEGUI_CEGUI_MultiColumnList_getColumnID00);
   tolua_function(tolua_S,"getRowID",tolua_CEGUI_CEGUI_MultiColumnList_getRowID00);
   tolua_function(tolua_S,"getRowWithID",tolua_CEGUI_CEGUI_MultiColumnList_getRowWithID00);
   tolua_function(tolua_S,"getListRenderArea",tolua_CEGUI_CEGUI_MultiColumnList_getListRenderArea00);
   tolua_function(tolua_S,"getVertScrollbar",tolua_CEGUI_CEGUI_MultiColumnList_getVertScrollbar00);
   tolua_function(tolua_S,"getHorzScrollbar",tolua_CEGUI_CEGUI_MultiColumnList_getHorzScrollbar00);
   tolua_function(tolua_S,"getListHeader",tolua_CEGUI_CEGUI_MultiColumnList_getListHeader00);
   tolua_function(tolua_S,"getTotalRowsHeight",tolua_CEGUI_CEGUI_MultiColumnList_getTotalRowsHeight00);
   tolua_function(tolua_S,"getWidestColumnItemWidth",tolua_CEGUI_CEGUI_MultiColumnList_getWidestColumnItemWidth00);
   tolua_function(tolua_S,"getHighestRowItemHeight",tolua_CEGUI_CEGUI_MultiColumnList_getHighestRowItemHeight00);
   tolua_function(tolua_S,"resetList",tolua_CEGUI_CEGUI_MultiColumnList_resetList00);
   tolua_function(tolua_S,"addColumn",tolua_CEGUI_CEGUI_MultiColumnList_addColumn00);
   tolua_function(tolua_S,"insertColumn",tolua_CEGUI_CEGUI_MultiColumnList_insertColumn00);
   tolua_function(tolua_S,"removeColumn",tolua_CEGUI_CEGUI_MultiColumnList_removeColumn00);
   tolua_function(tolua_S,"removeColumnWithID",tolua_CEGUI_CEGUI_MultiColumnList_removeColumnWithID00);
   tolua_function(tolua_S,"moveColumn",tolua_CEGUI_CEGUI_MultiColumnList_moveColumn00);
   tolua_function(tolua_S,"moveColumnWithID",tolua_CEGUI_CEGUI_MultiColumnList_moveColumnWithID00);
   tolua_function(tolua_S,"addRow",tolua_CEGUI_CEGUI_MultiColumnList_addRow00);
   tolua_function(tolua_S,"addRow",tolua_CEGUI_CEGUI_MultiColumnList_addRow01);
   tolua_function(tolua_S,"insertRow",tolua_CEGUI_CEGUI_MultiColumnList_insertRow00);
   tolua_function(tolua_S,"insertRow",tolua_CEGUI_CEGUI_MultiColumnList_insertRow01);
   tolua_function(tolua_S,"removeRow",tolua_CEGUI_CEGUI_MultiColumnList_removeRow00);
   tolua_function(tolua_S,"setItem",tolua_CEGUI_CEGUI_MultiColumnList_setItem00);
   tolua_function(tolua_S,"setItem",tolua_CEGUI_CEGUI_MultiColumnList_setItem01);
   tolua_function(tolua_S,"setSelectionMode",tolua_CEGUI_CEGUI_MultiColumnList_setSelectionMode00);
   tolua_function(tolua_S,"setNominatedSelectionColumnID",tolua_CEGUI_CEGUI_MultiColumnList_setNominatedSelectionColumnID00);
   tolua_function(tolua_S,"setNominatedSelectionColumn",tolua_CEGUI_CEGUI_MultiColumnList_setNominatedSelectionColumn00);
   tolua_function(tolua_S,"setNominatedSelectionRow",tolua_CEGUI_CEGUI_MultiColumnList_setNominatedSelectionRow00);
   tolua_function(tolua_S,"setSortDirection",tolua_CEGUI_CEGUI_MultiColumnList_setSortDirection00);
   tolua_function(tolua_S,"setSortColumn",tolua_CEGUI_CEGUI_MultiColumnList_setSortColumn00);
   tolua_function(tolua_S,"setSortColumnByID",tolua_CEGUI_CEGUI_MultiColumnList_setSortColumnByID00);
   tolua_function(tolua_S,"setShowVertScrollbar",tolua_CEGUI_CEGUI_MultiColumnList_setShowVertScrollbar00);
   tolua_function(tolua_S,"setShowHorzScrollbar",tolua_CEGUI_CEGUI_MultiColumnList_setShowHorzScrollbar00);
   tolua_function(tolua_S,"clearAllSelections",tolua_CEGUI_CEGUI_MultiColumnList_clearAllSelections00);
   tolua_function(tolua_S,"setItemSelectState",tolua_CEGUI_CEGUI_MultiColumnList_setItemSelectState00);
   tolua_function(tolua_S,"setItemSelectState",tolua_CEGUI_CEGUI_MultiColumnList_setItemSelectState01);
   tolua_function(tolua_S,"handleUpdatedItemData",tolua_CEGUI_CEGUI_MultiColumnList_handleUpdatedItemData00);
   tolua_function(tolua_S,"setColumnHeaderWidth",tolua_CEGUI_CEGUI_MultiColumnList_setColumnHeaderWidth00);
   tolua_function(tolua_S,"setUserSortControlEnabled",tolua_CEGUI_CEGUI_MultiColumnList_setUserSortControlEnabled00);
   tolua_function(tolua_S,"setUserColumnSizingEnabled",tolua_CEGUI_CEGUI_MultiColumnList_setUserColumnSizingEnabled00);
   tolua_function(tolua_S,"setUserColumnDraggingEnabled",tolua_CEGUI_CEGUI_MultiColumnList_setUserColumnDraggingEnabled00);
   tolua_function(tolua_S,"autoSizeColumnHeader",tolua_CEGUI_CEGUI_MultiColumnList_autoSizeColumnHeader00);
   tolua_function(tolua_S,"setRowID",tolua_CEGUI_CEGUI_MultiColumnList_setRowID00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ItemEntry","CEGUI::ItemEntry","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"ItemEntry");
   tolua_function(tolua_S,"getItemPixelSize",tolua_CEGUI_CEGUI_ItemEntry_getItemPixelSize00);
   tolua_function(tolua_S,"getOwnerList",tolua_CEGUI_CEGUI_ItemEntry_getOwnerList00);
   tolua_function(tolua_S,"isSelected",tolua_CEGUI_CEGUI_ItemEntry_isSelected00);
   tolua_function(tolua_S,"isSelectable",tolua_CEGUI_CEGUI_ItemEntry_isSelectable00);
   tolua_function(tolua_S,"setSelected",tolua_CEGUI_CEGUI_ItemEntry_setSelected00);
   tolua_function(tolua_S,"select",tolua_CEGUI_CEGUI_ItemEntry_select00);
   tolua_function(tolua_S,"deselect",tolua_CEGUI_CEGUI_ItemEntry_deselect00);
   tolua_function(tolua_S,"setSelectable",tolua_CEGUI_CEGUI_ItemEntry_setSelectable00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ItemListBase","CEGUI::ItemListBase","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"ItemListBase");
   tolua_constant(tolua_S,"Ascending",CEGUI::ItemListBase::Ascending);
   tolua_constant(tolua_S,"Descending",CEGUI::ItemListBase::Descending);
   tolua_constant(tolua_S,"UserSort",CEGUI::ItemListBase::UserSort);
   tolua_function(tolua_S,"getItemCount",tolua_CEGUI_CEGUI_ItemListBase_getItemCount00);
   tolua_function(tolua_S,"getItemFromIndex",tolua_CEGUI_CEGUI_ItemListBase_getItemFromIndex00);
   tolua_function(tolua_S,"getItemIndex",tolua_CEGUI_CEGUI_ItemListBase_getItemIndex00);
   tolua_function(tolua_S,"findItemWithText",tolua_CEGUI_CEGUI_ItemListBase_findItemWithText00);
   tolua_function(tolua_S,"isItemInList",tolua_CEGUI_CEGUI_ItemListBase_isItemInList00);
   tolua_function(tolua_S,"isAutoResizeEnabled",tolua_CEGUI_CEGUI_ItemListBase_isAutoResizeEnabled00);
   tolua_function(tolua_S,"isSortEnabled",tolua_CEGUI_CEGUI_ItemListBase_isSortEnabled00);
   tolua_function(tolua_S,"getSortMode",tolua_CEGUI_CEGUI_ItemListBase_getSortMode00);
   tolua_function(tolua_S,"getItemRenderArea",tolua_CEGUI_CEGUI_ItemListBase_getItemRenderArea00);
   tolua_function(tolua_S,"getContentPane",tolua_CEGUI_CEGUI_ItemListBase_getContentPane00);
   tolua_function(tolua_S,"resetList",tolua_CEGUI_CEGUI_ItemListBase_resetList00);
   tolua_function(tolua_S,"addItem",tolua_CEGUI_CEGUI_ItemListBase_addItem00);
   tolua_function(tolua_S,"insertItem",tolua_CEGUI_CEGUI_ItemListBase_insertItem00);
   tolua_function(tolua_S,"removeItem",tolua_CEGUI_CEGUI_ItemListBase_removeItem00);
   tolua_function(tolua_S,"handleUpdatedItemData",tolua_CEGUI_CEGUI_ItemListBase_handleUpdatedItemData00);
   tolua_function(tolua_S,"setAutoResizeEnabled",tolua_CEGUI_CEGUI_ItemListBase_setAutoResizeEnabled00);
   tolua_function(tolua_S,"sizeToContent",tolua_CEGUI_CEGUI_ItemListBase_sizeToContent00);
   tolua_function(tolua_S,"setSortEnabled",tolua_CEGUI_CEGUI_ItemListBase_setSortEnabled00);
   tolua_function(tolua_S,"setSortMode",tolua_CEGUI_CEGUI_ItemListBase_setSortMode00);
   tolua_function(tolua_S,"sortList",tolua_CEGUI_CEGUI_ItemListBase_sortList00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"MenuBase","CEGUI::MenuBase","CEGUI::ItemListBase",NULL);
  tolua_beginmodule(tolua_S,"MenuBase");
   tolua_function(tolua_S,"getItemSpacing",tolua_CEGUI_CEGUI_MenuBase_getItemSpacing00);
   tolua_function(tolua_S,"isMultiplePopupsAllowed",tolua_CEGUI_CEGUI_MenuBase_isMultiplePopupsAllowed00);
   tolua_function(tolua_S,"getPopupMenuItem",tolua_CEGUI_CEGUI_MenuBase_getPopupMenuItem00);
   tolua_function(tolua_S,"setItemSpacing",tolua_CEGUI_CEGUI_MenuBase_setItemSpacing00);
   tolua_function(tolua_S,"changePopupMenuItem",tolua_CEGUI_CEGUI_MenuBase_changePopupMenuItem00);
   tolua_function(tolua_S,"setAllowMultiplePopups",tolua_CEGUI_CEGUI_MenuBase_setAllowMultiplePopups00);
   tolua_function(tolua_S,"getAutoCloseNestedPopups",tolua_CEGUI_CEGUI_MenuBase_getAutoCloseNestedPopups00);
   tolua_function(tolua_S,"getPopupMenuItem",tolua_CEGUI_CEGUI_MenuBase_getPopupMenuItem01);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Menubar","CEGUI::Menubar","CEGUI::MenuBase",NULL);
  tolua_beginmodule(tolua_S,"Menubar");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"PopupMenu","CEGUI::PopupMenu","CEGUI::MenuBase",NULL);
  tolua_beginmodule(tolua_S,"PopupMenu");
   tolua_function(tolua_S,"getFadeInTime",tolua_CEGUI_CEGUI_PopupMenu_getFadeInTime00);
   tolua_function(tolua_S,"getFadeOutTime",tolua_CEGUI_CEGUI_PopupMenu_getFadeOutTime00);
   tolua_function(tolua_S,"setFadeInTime",tolua_CEGUI_CEGUI_PopupMenu_setFadeInTime00);
   tolua_function(tolua_S,"setFadeOutTime",tolua_CEGUI_CEGUI_PopupMenu_setFadeOutTime00);
   tolua_function(tolua_S,"openPopupMenu",tolua_CEGUI_CEGUI_PopupMenu_openPopupMenu00);
   tolua_function(tolua_S,"closePopupMenu",tolua_CEGUI_CEGUI_PopupMenu_closePopupMenu00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"MenuItem","CEGUI::MenuItem","CEGUI::ItemEntry",NULL);
  tolua_beginmodule(tolua_S,"MenuItem");
   tolua_function(tolua_S,"isHovering",tolua_CEGUI_CEGUI_MenuItem_isHovering00);
   tolua_function(tolua_S,"isPushed",tolua_CEGUI_CEGUI_MenuItem_isPushed00);
   tolua_function(tolua_S,"getPopupMenu",tolua_CEGUI_CEGUI_MenuItem_getPopupMenu00);
   tolua_function(tolua_S,"setPopupMenu",tolua_CEGUI_CEGUI_MenuItem_setPopupMenu00);
   tolua_function(tolua_S,"openPopupMenu",tolua_CEGUI_CEGUI_MenuItem_openPopupMenu00);
   tolua_function(tolua_S,"closePopupMenu",tolua_CEGUI_CEGUI_MenuItem_closePopupMenu00);
   tolua_function(tolua_S,"togglePopupMenu",tolua_CEGUI_CEGUI_MenuItem_togglePopupMenu00);
   tolua_function(tolua_S,"hasAutoPopup",tolua_CEGUI_CEGUI_MenuItem_hasAutoPopup00);
   tolua_function(tolua_S,"getAutoPopupTimeout",tolua_CEGUI_CEGUI_MenuItem_getAutoPopupTimeout00);
   tolua_function(tolua_S,"setAutoPopupTimeout",tolua_CEGUI_CEGUI_MenuItem_setAutoPopupTimeout00);
   tolua_function(tolua_S,"getPopupOffset",tolua_CEGUI_CEGUI_MenuItem_getPopupOffset00);
   tolua_function(tolua_S,"setPopupOffset",tolua_CEGUI_CEGUI_MenuItem_setPopupOffset00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ScrolledItemListBase","CEGUI::ScrolledItemListBase","CEGUI::ItemListBase",NULL);
  tolua_beginmodule(tolua_S,"ScrolledItemListBase");
   tolua_function(tolua_S,"isVertScrollbarAlwaysShown",tolua_CEGUI_CEGUI_ScrolledItemListBase_isVertScrollbarAlwaysShown00);
   tolua_function(tolua_S,"isHorzScrollbarAlwaysShown",tolua_CEGUI_CEGUI_ScrolledItemListBase_isHorzScrollbarAlwaysShown00);
   tolua_function(tolua_S,"getVertScrollbar",tolua_CEGUI_CEGUI_ScrolledItemListBase_getVertScrollbar00);
   tolua_function(tolua_S,"getHorzScrollbar",tolua_CEGUI_CEGUI_ScrolledItemListBase_getHorzScrollbar00);
   tolua_function(tolua_S,"setShowVertScrollbar",tolua_CEGUI_CEGUI_ScrolledItemListBase_setShowVertScrollbar00);
   tolua_function(tolua_S,"setShowHorzScrollbar",tolua_CEGUI_CEGUI_ScrolledItemListBase_setShowHorzScrollbar00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ItemListbox","CEGUI::ItemListbox","CEGUI::ScrolledItemListBase",NULL);
  tolua_beginmodule(tolua_S,"ItemListbox");
   tolua_function(tolua_S,"getSelectedCount",tolua_CEGUI_CEGUI_ItemListbox_getSelectedCount00);
   tolua_function(tolua_S,"getLastSelectedItem",tolua_CEGUI_CEGUI_ItemListbox_getLastSelectedItem00);
   tolua_function(tolua_S,"getFirstSelectedItem",tolua_CEGUI_CEGUI_ItemListbox_getFirstSelectedItem00);
   tolua_function(tolua_S,"getNextSelectedItem",tolua_CEGUI_CEGUI_ItemListbox_getNextSelectedItem00);
   tolua_function(tolua_S,"getNextSelectedItemAfter",tolua_CEGUI_CEGUI_ItemListbox_getNextSelectedItemAfter00);
   tolua_function(tolua_S,"isMultiSelectEnabled",tolua_CEGUI_CEGUI_ItemListbox_isMultiSelectEnabled00);
   tolua_function(tolua_S,"isItemSelected",tolua_CEGUI_CEGUI_ItemListbox_isItemSelected00);
   tolua_function(tolua_S,"setMultiSelectEnabled",tolua_CEGUI_CEGUI_ItemListbox_setMultiSelectEnabled00);
   tolua_function(tolua_S,"clearAllSelections",tolua_CEGUI_CEGUI_ItemListbox_clearAllSelections00);
   tolua_function(tolua_S,"selectRange",tolua_CEGUI_CEGUI_ItemListbox_selectRange00);
   tolua_function(tolua_S,"selectAllItems",tolua_CEGUI_CEGUI_ItemListbox_selectAllItems00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"GroupBox","CEGUI::GroupBox","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"GroupBox");
   tolua_function(tolua_S,"drawAroundWidget",tolua_CEGUI_CEGUI_GroupBox_drawAroundWidget00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"LayoutContainer","CEGUI::LayoutContainer","CEGUI::Window",NULL);
  tolua_beginmodule(tolua_S,"LayoutContainer");
   tolua_function(tolua_S,"markNeedsLayouting",tolua_CEGUI_CEGUI_LayoutContainer_markNeedsLayouting00);
   tolua_function(tolua_S,"needsLayouting",tolua_CEGUI_CEGUI_LayoutContainer_needsLayouting00);
   tolua_function(tolua_S,"layout",tolua_CEGUI_CEGUI_LayoutContainer_layout00);
   tolua_function(tolua_S,"layoutIfNecessary",tolua_CEGUI_CEGUI_LayoutContainer_layoutIfNecessary00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"SequentialLayoutContainer","CEGUI::SequentialLayoutContainer","CEGUI::LayoutContainer",NULL);
  tolua_beginmodule(tolua_S,"SequentialLayoutContainer");
   tolua_function(tolua_S,"getPositionOfChildWindow",tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChildWindow00);
   tolua_function(tolua_S,"getPositionOfChildWindow",tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChildWindow01);
   tolua_function(tolua_S,"getChildWindowAtPosition",tolua_CEGUI_CEGUI_SequentialLayoutContainer_getChildWindowAtPosition00);
   tolua_function(tolua_S,"swapChildWindowPositions",tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindowPositions00);
   tolua_function(tolua_S,"swapChildWindows",tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows00);
   tolua_function(tolua_S,"swapChildWindows",tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows01);
   tolua_function(tolua_S,"swapChildWindows",tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows02);
   tolua_function(tolua_S,"swapChildWindows",tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildWindows03);
   tolua_function(tolua_S,"moveChildWindowToPosition",tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildWindowToPosition00);
   tolua_function(tolua_S,"moveChildWindowToPosition",tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildWindowToPosition01);
   tolua_function(tolua_S,"moveChildWindow",tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildWindow00);
   tolua_function(tolua_S,"addChildWindowToPosition",tolua_CEGUI_CEGUI_SequentialLayoutContainer_addChildWindowToPosition00);
   tolua_function(tolua_S,"addChildWindowToPosition",tolua_CEGUI_CEGUI_SequentialLayoutContainer_addChildWindowToPosition01);
   tolua_function(tolua_S,"removeChildWindowFromPosition",tolua_CEGUI_CEGUI_SequentialLayoutContainer_removeChildWindowFromPosition00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"HorizontalLayoutContainer","CEGUI::HorizontalLayoutContainer","CEGUI::SequentialLayoutContainer",NULL);
  tolua_beginmodule(tolua_S,"HorizontalLayoutContainer");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"VerticalLayoutContainer","CEGUI::VerticalLayoutContainer","CEGUI::SequentialLayoutContainer",NULL);
  tolua_beginmodule(tolua_S,"VerticalLayoutContainer");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"GridLayoutContainer","CEGUI::GridLayoutContainer","CEGUI::LayoutContainer",NULL);
  tolua_beginmodule(tolua_S,"GridLayoutContainer");
   tolua_constant(tolua_S,"AP_Disabled",CEGUI::GridLayoutContainer::AP_Disabled);
   tolua_constant(tolua_S,"AP_LeftToRight",CEGUI::GridLayoutContainer::AP_LeftToRight);
   tolua_constant(tolua_S,"AP_TopToBottom",CEGUI::GridLayoutContainer::AP_TopToBottom);
   tolua_function(tolua_S,"setGridDimensions",tolua_CEGUI_CEGUI_GridLayoutContainer_setGridDimensions00);
   tolua_function(tolua_S,"getGridWidth",tolua_CEGUI_CEGUI_GridLayoutContainer_getGridWidth00);
   tolua_function(tolua_S,"getGridHeight",tolua_CEGUI_CEGUI_GridLayoutContainer_getGridHeight00);
   tolua_function(tolua_S,"setAutoPositioning",tolua_CEGUI_CEGUI_GridLayoutContainer_setAutoPositioning00);
   tolua_function(tolua_S,"getAutoPositioning",tolua_CEGUI_CEGUI_GridLayoutContainer_getAutoPositioning00);
   tolua_function(tolua_S,"setNextAutoPositioningIdx",tolua_CEGUI_CEGUI_GridLayoutContainer_setNextAutoPositioningIdx00);
   tolua_function(tolua_S,"getNextAutoPositioningIdx",tolua_CEGUI_CEGUI_GridLayoutContainer_getNextAutoPositioningIdx00);
   tolua_function(tolua_S,"autoPositioningSkipCells",tolua_CEGUI_CEGUI_GridLayoutContainer_autoPositioningSkipCells00);
   tolua_function(tolua_S,"addChildWindowToPosition",tolua_CEGUI_CEGUI_GridLayoutContainer_addChildWindowToPosition00);
   tolua_function(tolua_S,"addChildWindowToPosition",tolua_CEGUI_CEGUI_GridLayoutContainer_addChildWindowToPosition01);
   tolua_function(tolua_S,"getChildWindowAtPosition",tolua_CEGUI_CEGUI_GridLayoutContainer_getChildWindowAtPosition00);
   tolua_function(tolua_S,"removeChildWindowFromPosition",tolua_CEGUI_CEGUI_GridLayoutContainer_removeChildWindowFromPosition00);
   tolua_function(tolua_S,"swapChildWindowPositions",tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindowPositions00);
   tolua_function(tolua_S,"swapChildWindowPositions",tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindowPositions01);
   tolua_function(tolua_S,"swapChildWindows",tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindows00);
   tolua_function(tolua_S,"swapChildWindows",tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindows01);
   tolua_function(tolua_S,"swapChildWindows",tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildWindows02);
   tolua_function(tolua_S,"moveChildWindowToPosition",tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildWindowToPosition00);
   tolua_function(tolua_S,"moveChildWindowToPosition",tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildWindowToPosition01);
  tolua_endmodule(tolua_S);
  tolua_constant(tolua_S,"DT_LEFT_EDGE",CEGUI::DT_LEFT_EDGE);
  tolua_constant(tolua_S,"DT_X_POSITION",CEGUI::DT_X_POSITION);
  tolua_constant(tolua_S,"DT_TOP_EDGE",CEGUI::DT_TOP_EDGE);
  tolua_constant(tolua_S,"DT_Y_POSITION",CEGUI::DT_Y_POSITION);
  tolua_constant(tolua_S,"DT_RIGHT_EDGE",CEGUI::DT_RIGHT_EDGE);
  tolua_constant(tolua_S,"DT_BOTTOM_EDGE",CEGUI::DT_BOTTOM_EDGE);
  tolua_constant(tolua_S,"DT_WIDTH",CEGUI::DT_WIDTH);
  tolua_constant(tolua_S,"DT_HEIGHT",CEGUI::DT_HEIGHT);
  tolua_constant(tolua_S,"DT_X_OFFSET",CEGUI::DT_X_OFFSET);
  tolua_constant(tolua_S,"DT_Y_OFFSET",CEGUI::DT_Y_OFFSET);
  tolua_constant(tolua_S,"DT_INVALID",CEGUI::DT_INVALID);
  tolua_constant(tolua_S,"VF_TOP_ALIGNED",CEGUI::VF_TOP_ALIGNED);
  tolua_constant(tolua_S,"VF_CENTRE_ALIGNED",CEGUI::VF_CENTRE_ALIGNED);
  tolua_constant(tolua_S,"VF_BOTTOM_ALIGNED",CEGUI::VF_BOTTOM_ALIGNED);
  tolua_constant(tolua_S,"VF_STRETCHED",CEGUI::VF_STRETCHED);
  tolua_constant(tolua_S,"VF_TILED",CEGUI::VF_TILED);
  tolua_constant(tolua_S,"HF_LEFT_ALIGNED",CEGUI::HF_LEFT_ALIGNED);
  tolua_constant(tolua_S,"HF_CENTRE_ALIGNED",CEGUI::HF_CENTRE_ALIGNED);
  tolua_constant(tolua_S,"HF_RIGHT_ALIGNED",CEGUI::HF_RIGHT_ALIGNED);
  tolua_constant(tolua_S,"HF_STRETCHED",CEGUI::HF_STRETCHED);
  tolua_constant(tolua_S,"HF_TILED",CEGUI::HF_TILED);
  tolua_constant(tolua_S,"VTF_TOP_ALIGNED",CEGUI::VTF_TOP_ALIGNED);
  tolua_constant(tolua_S,"VTF_CENTRE_ALIGNED",CEGUI::VTF_CENTRE_ALIGNED);
  tolua_constant(tolua_S,"VTF_BOTTOM_ALIGNED",CEGUI::VTF_BOTTOM_ALIGNED);
  tolua_constant(tolua_S,"HTF_LEFT_ALIGNED",CEGUI::HTF_LEFT_ALIGNED);
  tolua_constant(tolua_S,"HTF_RIGHT_ALIGNED",CEGUI::HTF_RIGHT_ALIGNED);
  tolua_constant(tolua_S,"HTF_CENTRE_ALIGNED",CEGUI::HTF_CENTRE_ALIGNED);
  tolua_constant(tolua_S,"HTF_JUSTIFIED",CEGUI::HTF_JUSTIFIED);
  tolua_constant(tolua_S,"HTF_WORDWRAP_LEFT_ALIGNED",CEGUI::HTF_WORDWRAP_LEFT_ALIGNED);
  tolua_constant(tolua_S,"HTF_WORDWRAP_RIGHT_ALIGNED",CEGUI::HTF_WORDWRAP_RIGHT_ALIGNED);
  tolua_constant(tolua_S,"HTF_WORDWRAP_CENTRE_ALIGNED",CEGUI::HTF_WORDWRAP_CENTRE_ALIGNED);
  tolua_constant(tolua_S,"HTF_WORDWRAP_JUSTIFIED",CEGUI::HTF_WORDWRAP_JUSTIFIED);
  tolua_constant(tolua_S,"FMT_LINE_SPACING",CEGUI::FMT_LINE_SPACING);
  tolua_constant(tolua_S,"FMT_BASELINE",CEGUI::FMT_BASELINE);
  tolua_constant(tolua_S,"FMT_HORZ_EXTENT",CEGUI::FMT_HORZ_EXTENT);
  tolua_constant(tolua_S,"DOP_NOOP",CEGUI::DOP_NOOP);
  tolua_constant(tolua_S,"DOP_ADD",CEGUI::DOP_ADD);
  tolua_constant(tolua_S,"DOP_SUBTRACT",CEGUI::DOP_SUBTRACT);
  tolua_constant(tolua_S,"DOP_MULTIPLY",CEGUI::DOP_MULTIPLY);
  tolua_constant(tolua_S,"DOP_DIVIDE",CEGUI::DOP_DIVIDE);
  tolua_constant(tolua_S,"FIC_BACKGROUND",CEGUI::FIC_BACKGROUND);
  tolua_constant(tolua_S,"FIC_TOP_LEFT_CORNER",CEGUI::FIC_TOP_LEFT_CORNER);
  tolua_constant(tolua_S,"FIC_TOP_RIGHT_CORNER",CEGUI::FIC_TOP_RIGHT_CORNER);
  tolua_constant(tolua_S,"FIC_BOTTOM_LEFT_CORNER",CEGUI::FIC_BOTTOM_LEFT_CORNER);
  tolua_constant(tolua_S,"FIC_BOTTOM_RIGHT_CORNER",CEGUI::FIC_BOTTOM_RIGHT_CORNER);
  tolua_constant(tolua_S,"FIC_LEFT_EDGE",CEGUI::FIC_LEFT_EDGE);
  tolua_constant(tolua_S,"FIC_RIGHT_EDGE",CEGUI::FIC_RIGHT_EDGE);
  tolua_constant(tolua_S,"FIC_TOP_EDGE",CEGUI::FIC_TOP_EDGE);
  tolua_constant(tolua_S,"FIC_BOTTOM_EDGE",CEGUI::FIC_BOTTOM_EDGE);
  tolua_constant(tolua_S,"FIC_FRAME_IMAGE_COUNT",CEGUI::FIC_FRAME_IMAGE_COUNT);
  tolua_cclass(tolua_S,"BaseDim","CEGUI::BaseDim","",NULL);
  tolua_beginmodule(tolua_S,"BaseDim");
   tolua_function(tolua_S,"getValue",tolua_CEGUI_CEGUI_BaseDim_getValue00);
   tolua_function(tolua_S,"getValue",tolua_CEGUI_CEGUI_BaseDim_getValue01);
   tolua_function(tolua_S,"clone",tolua_CEGUI_CEGUI_BaseDim_clone00);
   tolua_function(tolua_S,"getDimensionOperator",tolua_CEGUI_CEGUI_BaseDim_getDimensionOperator00);
   tolua_function(tolua_S,"setDimensionOperator",tolua_CEGUI_CEGUI_BaseDim_setDimensionOperator00);
   tolua_function(tolua_S,"getOperand",tolua_CEGUI_CEGUI_BaseDim_getOperand00);
   tolua_function(tolua_S,"setOperand",tolua_CEGUI_CEGUI_BaseDim_setOperand00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"AbsoluteDim","CEGUI::AbsoluteDim","CEGUI::BaseDim",tolua_collect_CEGUI__AbsoluteDim);
  #else
  tolua_cclass(tolua_S,"AbsoluteDim","CEGUI::AbsoluteDim","CEGUI::BaseDim",NULL);
  #endif
  tolua_beginmodule(tolua_S,"AbsoluteDim");
   tolua_function(tolua_S,"setValue",tolua_CEGUI_CEGUI_AbsoluteDim_setValue00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_AbsoluteDim_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_AbsoluteDim_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_AbsoluteDim_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"ImageDim","CEGUI::ImageDim","CEGUI::BaseDim",tolua_collect_CEGUI__ImageDim);
  #else
  tolua_cclass(tolua_S,"ImageDim","CEGUI::ImageDim","CEGUI::BaseDim",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ImageDim");
   tolua_function(tolua_S,"setSourceImage",tolua_CEGUI_CEGUI_ImageDim_setSourceImage00);
   tolua_function(tolua_S,"setSourceDimension",tolua_CEGUI_CEGUI_ImageDim_setSourceDimension00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_ImageDim_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_ImageDim_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_ImageDim_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"WidgetDim","CEGUI::WidgetDim","CEGUI::BaseDim",tolua_collect_CEGUI__WidgetDim);
  #else
  tolua_cclass(tolua_S,"WidgetDim","CEGUI::WidgetDim","CEGUI::BaseDim",NULL);
  #endif
  tolua_beginmodule(tolua_S,"WidgetDim");
   tolua_function(tolua_S,"setWidgetName",tolua_CEGUI_CEGUI_WidgetDim_setWidgetName00);
   tolua_function(tolua_S,"setSourceDimension",tolua_CEGUI_CEGUI_WidgetDim_setSourceDimension00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_WidgetDim_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_WidgetDim_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_WidgetDim_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"UnifiedDim","CEGUI::UnifiedDim","CEGUI::BaseDim",tolua_collect_CEGUI__UnifiedDim);
  #else
  tolua_cclass(tolua_S,"UnifiedDim","CEGUI::UnifiedDim","CEGUI::BaseDim",NULL);
  #endif
  tolua_beginmodule(tolua_S,"UnifiedDim");
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_UnifiedDim_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_UnifiedDim_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_UnifiedDim_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"FontDim","CEGUI::FontDim","CEGUI::BaseDim",tolua_collect_CEGUI__FontDim);
  #else
  tolua_cclass(tolua_S,"FontDim","CEGUI::FontDim","CEGUI::BaseDim",NULL);
  #endif
  tolua_beginmodule(tolua_S,"FontDim");
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_FontDim_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_FontDim_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_FontDim_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"PropertyDim","CEGUI::PropertyDim","CEGUI::BaseDim",tolua_collect_CEGUI__PropertyDim);
  #else
  tolua_cclass(tolua_S,"PropertyDim","CEGUI::PropertyDim","CEGUI::BaseDim",NULL);
  #endif
  tolua_beginmodule(tolua_S,"PropertyDim");
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_PropertyDim_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_PropertyDim_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_PropertyDim_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Dimension","CEGUI::Dimension","",tolua_collect_CEGUI__Dimension);
  #else
  tolua_cclass(tolua_S,"Dimension","CEGUI::Dimension","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Dimension");
   tolua_function(tolua_S,"getBaseDimension",tolua_CEGUI_CEGUI_Dimension_getBaseDimension00);
   tolua_function(tolua_S,"setBaseDimension",tolua_CEGUI_CEGUI_Dimension_setBaseDimension00);
   tolua_function(tolua_S,"getDimensionType",tolua_CEGUI_CEGUI_Dimension_getDimensionType00);
   tolua_function(tolua_S,"setDimensionType",tolua_CEGUI_CEGUI_Dimension_setDimensionType00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Dimension_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Dimension_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Dimension_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Dimension_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Dimension_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Dimension_new01_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Dimension_new02);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Dimension_new02_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Dimension_new02_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"ComponentArea","CEGUI::ComponentArea","",tolua_collect_CEGUI__ComponentArea);
  #else
  tolua_cclass(tolua_S,"ComponentArea","CEGUI::ComponentArea","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ComponentArea");
   tolua_function(tolua_S,"getPixelRect",tolua_CEGUI_CEGUI_ComponentArea_getPixelRect00);
   tolua_function(tolua_S,"getPixelRect",tolua_CEGUI_CEGUI_ComponentArea_getPixelRect01);
   tolua_function(tolua_S,"isAreaFetchedFromProperty",tolua_CEGUI_CEGUI_ComponentArea_isAreaFetchedFromProperty00);
   tolua_function(tolua_S,"getAreaPropertySource",tolua_CEGUI_CEGUI_ComponentArea_getAreaPropertySource00);
   tolua_function(tolua_S,"setAreaPropertySource",tolua_CEGUI_CEGUI_ComponentArea_setAreaPropertySource00);
   tolua_variable(tolua_S,"d_left",tolua_get_CEGUI__ComponentArea_d_left,tolua_set_CEGUI__ComponentArea_d_left);
   tolua_variable(tolua_S,"d_top",tolua_get_CEGUI__ComponentArea_d_top,tolua_set_CEGUI__ComponentArea_d_top);
   tolua_variable(tolua_S,"d_right_or_width",tolua_get_CEGUI__ComponentArea_d_right_or_width,tolua_set_CEGUI__ComponentArea_d_right_or_width);
   tolua_variable(tolua_S,"d_bottom_or_height",tolua_get_CEGUI__ComponentArea_d_bottom_or_height,tolua_set_CEGUI__ComponentArea_d_bottom_or_height);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_ComponentArea_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_ComponentArea_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_ComponentArea_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"NamedArea","CEGUI::NamedArea","",tolua_collect_CEGUI__NamedArea);
  #else
  tolua_cclass(tolua_S,"NamedArea","CEGUI::NamedArea","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"NamedArea");
   tolua_function(tolua_S,"getName",tolua_CEGUI_CEGUI_NamedArea_getName00);
   tolua_function(tolua_S,"getArea",tolua_CEGUI_CEGUI_NamedArea_getArea00);
   tolua_function(tolua_S,"setArea",tolua_CEGUI_CEGUI_NamedArea_setArea00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_NamedArea_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_NamedArea_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_NamedArea_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_NamedArea_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_NamedArea_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_NamedArea_new01_local);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"PropertyDefinitionBase","CEGUI::PropertyDefinitionBase","CEGUI::Property",NULL);
  tolua_beginmodule(tolua_S,"PropertyDefinitionBase");
   tolua_function(tolua_S,"set",tolua_CEGUI_CEGUI_PropertyDefinitionBase_set00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"PropertyDefinition","CEGUI::PropertyDefinition","CEGUI::PropertyDefinitionBase",tolua_collect_CEGUI__PropertyDefinition);
  #else
  tolua_cclass(tolua_S,"PropertyDefinition","CEGUI::PropertyDefinition","CEGUI::PropertyDefinitionBase",NULL);
  #endif
  tolua_beginmodule(tolua_S,"PropertyDefinition");
   tolua_function(tolua_S,"get",tolua_CEGUI_CEGUI_PropertyDefinition_get00);
   tolua_function(tolua_S,"set",tolua_CEGUI_CEGUI_PropertyDefinition_set00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_PropertyDefinition_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_PropertyDefinition_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_PropertyDefinition_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"PropertyInitialiser","CEGUI::PropertyInitialiser","",tolua_collect_CEGUI__PropertyInitialiser);
  #else
  tolua_cclass(tolua_S,"PropertyInitialiser","CEGUI::PropertyInitialiser","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"PropertyInitialiser");
   tolua_function(tolua_S,"apply",tolua_CEGUI_CEGUI_PropertyInitialiser_apply00);
   tolua_function(tolua_S,"getTargetPropertyName",tolua_CEGUI_CEGUI_PropertyInitialiser_getTargetPropertyName00);
   tolua_function(tolua_S,"getInitialiserValue",tolua_CEGUI_CEGUI_PropertyInitialiser_getInitialiserValue00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_PropertyInitialiser_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_PropertyInitialiser_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_PropertyInitialiser_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"PropertyLinkDefinition","CEGUI::PropertyLinkDefinition","CEGUI::PropertyDefinitionBase",tolua_collect_CEGUI__PropertyLinkDefinition);
  #else
  tolua_cclass(tolua_S,"PropertyLinkDefinition","CEGUI::PropertyLinkDefinition","CEGUI::PropertyDefinitionBase",NULL);
  #endif
  tolua_beginmodule(tolua_S,"PropertyLinkDefinition");
   tolua_function(tolua_S,"get",tolua_CEGUI_CEGUI_PropertyLinkDefinition_get00);
   tolua_function(tolua_S,"set",tolua_CEGUI_CEGUI_PropertyLinkDefinition_set00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_PropertyLinkDefinition_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_PropertyLinkDefinition_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_PropertyLinkDefinition_new00_local);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"FalagardComponentBase","CEGUI::FalagardComponentBase","",NULL);
  tolua_beginmodule(tolua_S,"FalagardComponentBase");
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_FalagardComponentBase_render00);
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_FalagardComponentBase_render01);
   tolua_function(tolua_S,"getComponentArea",tolua_CEGUI_CEGUI_FalagardComponentBase_getComponentArea00);
   tolua_function(tolua_S,"setComponentArea",tolua_CEGUI_CEGUI_FalagardComponentBase_setComponentArea00);
   tolua_function(tolua_S,"getColours",tolua_CEGUI_CEGUI_FalagardComponentBase_getColours00);
   tolua_function(tolua_S,"setColours",tolua_CEGUI_CEGUI_FalagardComponentBase_setColours00);
   tolua_function(tolua_S,"setColoursPropertySource",tolua_CEGUI_CEGUI_FalagardComponentBase_setColoursPropertySource00);
   tolua_function(tolua_S,"setColoursPropertyIsColourRect",tolua_CEGUI_CEGUI_FalagardComponentBase_setColoursPropertyIsColourRect00);
   tolua_function(tolua_S,"setVertFormattingPropertySource",tolua_CEGUI_CEGUI_FalagardComponentBase_setVertFormattingPropertySource00);
   tolua_function(tolua_S,"setHorzFormattingPropertySource",tolua_CEGUI_CEGUI_FalagardComponentBase_setHorzFormattingPropertySource00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"FrameComponent","CEGUI::FrameComponent","CEGUI::FalagardComponentBase",tolua_collect_CEGUI__FrameComponent);
  #else
  tolua_cclass(tolua_S,"FrameComponent","CEGUI::FrameComponent","CEGUI::FalagardComponentBase",NULL);
  #endif
  tolua_beginmodule(tolua_S,"FrameComponent");
   tolua_function(tolua_S,"getBackgroundVerticalFormatting",tolua_CEGUI_CEGUI_FrameComponent_getBackgroundVerticalFormatting00);
   tolua_function(tolua_S,"setBackgroundVerticalFormatting",tolua_CEGUI_CEGUI_FrameComponent_setBackgroundVerticalFormatting00);
   tolua_function(tolua_S,"getBackgroundHorizontalFormatting",tolua_CEGUI_CEGUI_FrameComponent_getBackgroundHorizontalFormatting00);
   tolua_function(tolua_S,"setBackgroundHorizontalFormatting",tolua_CEGUI_CEGUI_FrameComponent_setBackgroundHorizontalFormatting00);
   tolua_function(tolua_S,"getImage",tolua_CEGUI_CEGUI_FrameComponent_getImage00);
   tolua_function(tolua_S,"setImage",tolua_CEGUI_CEGUI_FrameComponent_setImage00);
   tolua_function(tolua_S,"setImage",tolua_CEGUI_CEGUI_FrameComponent_setImage01);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_FrameComponent_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_FrameComponent_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_FrameComponent_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"ImageryComponent","CEGUI::ImageryComponent","CEGUI::FalagardComponentBase",tolua_collect_CEGUI__ImageryComponent);
  #else
  tolua_cclass(tolua_S,"ImageryComponent","CEGUI::ImageryComponent","CEGUI::FalagardComponentBase",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ImageryComponent");
   tolua_function(tolua_S,"getImage",tolua_CEGUI_CEGUI_ImageryComponent_getImage00);
   tolua_function(tolua_S,"setImage",tolua_CEGUI_CEGUI_ImageryComponent_setImage00);
   tolua_function(tolua_S,"setImage",tolua_CEGUI_CEGUI_ImageryComponent_setImage01);
   tolua_function(tolua_S,"getVerticalFormatting",tolua_CEGUI_CEGUI_ImageryComponent_getVerticalFormatting00);
   tolua_function(tolua_S,"setVerticalFormatting",tolua_CEGUI_CEGUI_ImageryComponent_setVerticalFormatting00);
   tolua_function(tolua_S,"getHorizontalFormatting",tolua_CEGUI_CEGUI_ImageryComponent_getHorizontalFormatting00);
   tolua_function(tolua_S,"setHorizontalFormatting",tolua_CEGUI_CEGUI_ImageryComponent_setHorizontalFormatting00);
   tolua_function(tolua_S,"isImageFetchedFromProperty",tolua_CEGUI_CEGUI_ImageryComponent_isImageFetchedFromProperty00);
   tolua_function(tolua_S,"getImagePropertySource",tolua_CEGUI_CEGUI_ImageryComponent_getImagePropertySource00);
   tolua_function(tolua_S,"setImagePropertySource",tolua_CEGUI_CEGUI_ImageryComponent_setImagePropertySource00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_ImageryComponent_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_ImageryComponent_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_ImageryComponent_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"TextComponent","CEGUI::TextComponent","CEGUI::FalagardComponentBase",tolua_collect_CEGUI__TextComponent);
  #else
  tolua_cclass(tolua_S,"TextComponent","CEGUI::TextComponent","CEGUI::FalagardComponentBase",NULL);
  #endif
  tolua_beginmodule(tolua_S,"TextComponent");
   tolua_function(tolua_S,"getText",tolua_CEGUI_CEGUI_TextComponent_getText00);
   tolua_function(tolua_S,"setText",tolua_CEGUI_CEGUI_TextComponent_setText00);
   tolua_function(tolua_S,"getFont",tolua_CEGUI_CEGUI_TextComponent_getFont00);
   tolua_function(tolua_S,"setFont",tolua_CEGUI_CEGUI_TextComponent_setFont00);
   tolua_function(tolua_S,"getVerticalFormatting",tolua_CEGUI_CEGUI_TextComponent_getVerticalFormatting00);
   tolua_function(tolua_S,"setVerticalFormatting",tolua_CEGUI_CEGUI_TextComponent_setVerticalFormatting00);
   tolua_function(tolua_S,"getHorizontalFormatting",tolua_CEGUI_CEGUI_TextComponent_getHorizontalFormatting00);
   tolua_function(tolua_S,"setHorizontalFormatting",tolua_CEGUI_CEGUI_TextComponent_setHorizontalFormatting00);
   tolua_function(tolua_S,"isTextFetchedFromProperty",tolua_CEGUI_CEGUI_TextComponent_isTextFetchedFromProperty00);
   tolua_function(tolua_S,"getTextPropertySource",tolua_CEGUI_CEGUI_TextComponent_getTextPropertySource00);
   tolua_function(tolua_S,"setTextPropertySource",tolua_CEGUI_CEGUI_TextComponent_setTextPropertySource00);
   tolua_function(tolua_S,"isFontFetchedFromProperty",tolua_CEGUI_CEGUI_TextComponent_isFontFetchedFromProperty00);
   tolua_function(tolua_S,"getFontPropertySource",tolua_CEGUI_CEGUI_TextComponent_getFontPropertySource00);
   tolua_function(tolua_S,"setFontPropertySource",tolua_CEGUI_CEGUI_TextComponent_setFontPropertySource00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_TextComponent_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_TextComponent_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_TextComponent_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"ImagerySection","CEGUI::ImagerySection","",tolua_collect_CEGUI__ImagerySection);
  #else
  tolua_cclass(tolua_S,"ImagerySection","CEGUI::ImagerySection","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ImagerySection");
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_ImagerySection_render00);
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_ImagerySection_render01);
   tolua_function(tolua_S,"addImageryComponent",tolua_CEGUI_CEGUI_ImagerySection_addImageryComponent00);
   tolua_function(tolua_S,"clearImageryComponents",tolua_CEGUI_CEGUI_ImagerySection_clearImageryComponents00);
   tolua_function(tolua_S,"addTextComponent",tolua_CEGUI_CEGUI_ImagerySection_addTextComponent00);
   tolua_function(tolua_S,"clearTextComponents",tolua_CEGUI_CEGUI_ImagerySection_clearTextComponents00);
   tolua_function(tolua_S,"clearFrameComponents",tolua_CEGUI_CEGUI_ImagerySection_clearFrameComponents00);
   tolua_function(tolua_S,"addFrameComponent",tolua_CEGUI_CEGUI_ImagerySection_addFrameComponent00);
   tolua_function(tolua_S,"getMasterColours",tolua_CEGUI_CEGUI_ImagerySection_getMasterColours00);
   tolua_function(tolua_S,"setMasterColours",tolua_CEGUI_CEGUI_ImagerySection_setMasterColours00);
   tolua_function(tolua_S,"getName",tolua_CEGUI_CEGUI_ImagerySection_getName00);
   tolua_function(tolua_S,"setMasterColoursPropertySource",tolua_CEGUI_CEGUI_ImagerySection_setMasterColoursPropertySource00);
   tolua_function(tolua_S,"setMasterColoursPropertyIsColourRect",tolua_CEGUI_CEGUI_ImagerySection_setMasterColoursPropertyIsColourRect00);
   tolua_function(tolua_S,"getBoundingRect",tolua_CEGUI_CEGUI_ImagerySection_getBoundingRect00);
   tolua_function(tolua_S,"getBoundingRect",tolua_CEGUI_CEGUI_ImagerySection_getBoundingRect01);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_ImagerySection_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_ImagerySection_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_ImagerySection_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_ImagerySection_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_ImagerySection_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_ImagerySection_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"SectionSpecification","CEGUI::SectionSpecification","",tolua_collect_CEGUI__SectionSpecification);
  #else
  tolua_cclass(tolua_S,"SectionSpecification","CEGUI::SectionSpecification","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"SectionSpecification");
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_SectionSpecification_render00);
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_SectionSpecification_render01);
   tolua_function(tolua_S,"getOwnerWidgetLookFeel",tolua_CEGUI_CEGUI_SectionSpecification_getOwnerWidgetLookFeel00);
   tolua_function(tolua_S,"getSectionName",tolua_CEGUI_CEGUI_SectionSpecification_getSectionName00);
   tolua_function(tolua_S,"getOverrideColours",tolua_CEGUI_CEGUI_SectionSpecification_getOverrideColours00);
   tolua_function(tolua_S,"setOverrideColours",tolua_CEGUI_CEGUI_SectionSpecification_setOverrideColours00);
   tolua_function(tolua_S,"isUsingOverrideColours",tolua_CEGUI_CEGUI_SectionSpecification_isUsingOverrideColours00);
   tolua_function(tolua_S,"setUsingOverrideColours",tolua_CEGUI_CEGUI_SectionSpecification_setUsingOverrideColours00);
   tolua_function(tolua_S,"setOverrideColoursPropertySource",tolua_CEGUI_CEGUI_SectionSpecification_setOverrideColoursPropertySource00);
   tolua_function(tolua_S,"setOverrideColoursPropertyIsColourRect",tolua_CEGUI_CEGUI_SectionSpecification_setOverrideColoursPropertyIsColourRect00);
   tolua_function(tolua_S,"setRenderControlPropertySource",tolua_CEGUI_CEGUI_SectionSpecification_setRenderControlPropertySource00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_SectionSpecification_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_SectionSpecification_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_SectionSpecification_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_SectionSpecification_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_SectionSpecification_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_SectionSpecification_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"LayerSpecification","CEGUI::LayerSpecification","",tolua_collect_CEGUI__LayerSpecification);
  #else
  tolua_cclass(tolua_S,"LayerSpecification","CEGUI::LayerSpecification","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"LayerSpecification");
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_LayerSpecification_render00);
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_LayerSpecification_render01);
   tolua_function(tolua_S,"addSectionSpecification",tolua_CEGUI_CEGUI_LayerSpecification_addSectionSpecification00);
   tolua_function(tolua_S,"clearSectionSpecifications",tolua_CEGUI_CEGUI_LayerSpecification_clearSectionSpecifications00);
   tolua_function(tolua_S,"getLayerPriority",tolua_CEGUI_CEGUI_LayerSpecification_getLayerPriority00);
   tolua_function(tolua_S,".lt",tolua_CEGUI_CEGUI_LayerSpecification__lt00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_LayerSpecification_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_LayerSpecification_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_LayerSpecification_new00_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"StateImagery","CEGUI::StateImagery","",tolua_collect_CEGUI__StateImagery);
  #else
  tolua_cclass(tolua_S,"StateImagery","CEGUI::StateImagery","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"StateImagery");
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_StateImagery_render00);
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_StateImagery_render01);
   tolua_function(tolua_S,"addLayer",tolua_CEGUI_CEGUI_StateImagery_addLayer00);
   tolua_function(tolua_S,"clearLayers",tolua_CEGUI_CEGUI_StateImagery_clearLayers00);
   tolua_function(tolua_S,"getName",tolua_CEGUI_CEGUI_StateImagery_getName00);
   tolua_function(tolua_S,"isClippedToDisplay",tolua_CEGUI_CEGUI_StateImagery_isClippedToDisplay00);
   tolua_function(tolua_S,"setClippedToDisplay",tolua_CEGUI_CEGUI_StateImagery_setClippedToDisplay00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_StateImagery_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_StateImagery_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_StateImagery_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_StateImagery_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_StateImagery_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_StateImagery_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"WidgetComponent","CEGUI::WidgetComponent","",tolua_collect_CEGUI__WidgetComponent);
  #else
  tolua_cclass(tolua_S,"WidgetComponent","CEGUI::WidgetComponent","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"WidgetComponent");
   tolua_function(tolua_S,"create",tolua_CEGUI_CEGUI_WidgetComponent_create00);
   tolua_function(tolua_S,"getComponentArea",tolua_CEGUI_CEGUI_WidgetComponent_getComponentArea00);
   tolua_function(tolua_S,"setComponentArea",tolua_CEGUI_CEGUI_WidgetComponent_setComponentArea00);
   tolua_function(tolua_S,"getBaseWidgetType",tolua_CEGUI_CEGUI_WidgetComponent_getBaseWidgetType00);
   tolua_function(tolua_S,"setBaseWidgetType",tolua_CEGUI_CEGUI_WidgetComponent_setBaseWidgetType00);
   tolua_function(tolua_S,"getWidgetLookName",tolua_CEGUI_CEGUI_WidgetComponent_getWidgetLookName00);
   tolua_function(tolua_S,"setWidgetLookName",tolua_CEGUI_CEGUI_WidgetComponent_setWidgetLookName00);
   tolua_function(tolua_S,"getWidgetNameSuffix",tolua_CEGUI_CEGUI_WidgetComponent_getWidgetNameSuffix00);
   tolua_function(tolua_S,"setWidgetNameSuffix",tolua_CEGUI_CEGUI_WidgetComponent_setWidgetNameSuffix00);
   tolua_function(tolua_S,"getWindowRendererType",tolua_CEGUI_CEGUI_WidgetComponent_getWindowRendererType00);
   tolua_function(tolua_S,"setWindowRendererType",tolua_CEGUI_CEGUI_WidgetComponent_setWindowRendererType00);
   tolua_function(tolua_S,"getVerticalWidgetAlignment",tolua_CEGUI_CEGUI_WidgetComponent_getVerticalWidgetAlignment00);
   tolua_function(tolua_S,"setVerticalWidgetAlignment",tolua_CEGUI_CEGUI_WidgetComponent_setVerticalWidgetAlignment00);
   tolua_function(tolua_S,"getHorizontalWidgetAlignment",tolua_CEGUI_CEGUI_WidgetComponent_getHorizontalWidgetAlignment00);
   tolua_function(tolua_S,"setHorizontalWidgetAlignment",tolua_CEGUI_CEGUI_WidgetComponent_setHorizontalWidgetAlignment00);
   tolua_function(tolua_S,"addPropertyInitialiser",tolua_CEGUI_CEGUI_WidgetComponent_addPropertyInitialiser00);
   tolua_function(tolua_S,"clearPropertyInitialisers",tolua_CEGUI_CEGUI_WidgetComponent_clearPropertyInitialisers00);
   tolua_function(tolua_S,"layout",tolua_CEGUI_CEGUI_WidgetComponent_layout00);
   tolua_function(tolua_S,"findPropertyInitialiser",tolua_CEGUI_CEGUI_WidgetComponent_findPropertyInitialiser00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_WidgetComponent_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_WidgetComponent_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_WidgetComponent_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_WidgetComponent_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_WidgetComponent_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_WidgetComponent_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"WidgetLookFeel","CEGUI::WidgetLookFeel","",tolua_collect_CEGUI__WidgetLookFeel);
  #else
  tolua_cclass(tolua_S,"WidgetLookFeel","CEGUI::WidgetLookFeel","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"WidgetLookFeel");
   tolua_function(tolua_S,"getStateImagery",tolua_CEGUI_CEGUI_WidgetLookFeel_getStateImagery00);
   tolua_function(tolua_S,"getImagerySection",tolua_CEGUI_CEGUI_WidgetLookFeel_getImagerySection00);
   tolua_function(tolua_S,"getName",tolua_CEGUI_CEGUI_WidgetLookFeel_getName00);
   tolua_function(tolua_S,"addImagerySection",tolua_CEGUI_CEGUI_WidgetLookFeel_addImagerySection00);
   tolua_function(tolua_S,"addWidgetComponent",tolua_CEGUI_CEGUI_WidgetLookFeel_addWidgetComponent00);
   tolua_function(tolua_S,"addStateSpecification",tolua_CEGUI_CEGUI_WidgetLookFeel_addStateSpecification00);
   tolua_function(tolua_S,"addPropertyInitialiser",tolua_CEGUI_CEGUI_WidgetLookFeel_addPropertyInitialiser00);
   tolua_function(tolua_S,"clearImagerySections",tolua_CEGUI_CEGUI_WidgetLookFeel_clearImagerySections00);
   tolua_function(tolua_S,"clearWidgetComponents",tolua_CEGUI_CEGUI_WidgetLookFeel_clearWidgetComponents00);
   tolua_function(tolua_S,"clearStateSpecifications",tolua_CEGUI_CEGUI_WidgetLookFeel_clearStateSpecifications00);
   tolua_function(tolua_S,"clearPropertyInitialisers",tolua_CEGUI_CEGUI_WidgetLookFeel_clearPropertyInitialisers00);
   tolua_function(tolua_S,"initialiseWidget",tolua_CEGUI_CEGUI_WidgetLookFeel_initialiseWidget00);
   tolua_function(tolua_S,"isStateImageryPresent",tolua_CEGUI_CEGUI_WidgetLookFeel_isStateImageryPresent00);
   tolua_function(tolua_S,"addNamedArea",tolua_CEGUI_CEGUI_WidgetLookFeel_addNamedArea00);
   tolua_function(tolua_S,"clearNamedAreas",tolua_CEGUI_CEGUI_WidgetLookFeel_clearNamedAreas00);
   tolua_function(tolua_S,"getNamedArea",tolua_CEGUI_CEGUI_WidgetLookFeel_getNamedArea00);
   tolua_function(tolua_S,"isNamedAreaDefined",tolua_CEGUI_CEGUI_WidgetLookFeel_isNamedAreaDefined00);
   tolua_function(tolua_S,"layoutChildWidgets",tolua_CEGUI_CEGUI_WidgetLookFeel_layoutChildWidgets00);
   tolua_function(tolua_S,"addPropertyDefinition",tolua_CEGUI_CEGUI_WidgetLookFeel_addPropertyDefinition00);
   tolua_function(tolua_S,"addPropertyLinkDefinition",tolua_CEGUI_CEGUI_WidgetLookFeel_addPropertyLinkDefinition00);
   tolua_function(tolua_S,"clearPropertyDefinitions",tolua_CEGUI_CEGUI_WidgetLookFeel_clearPropertyDefinitions00);
   tolua_function(tolua_S,"clearPropertyLinkDefinitions",tolua_CEGUI_CEGUI_WidgetLookFeel_clearPropertyLinkDefinitions00);
   tolua_function(tolua_S,"renameChildren",tolua_CEGUI_CEGUI_WidgetLookFeel_renameChildren00);
   tolua_function(tolua_S,"findPropertyInitialiser",tolua_CEGUI_CEGUI_WidgetLookFeel_findPropertyInitialiser00);
   tolua_function(tolua_S,"findWidgetComponent",tolua_CEGUI_CEGUI_WidgetLookFeel_findWidgetComponent00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_WidgetLookFeel_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_WidgetLookFeel_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_WidgetLookFeel_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_WidgetLookFeel_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_WidgetLookFeel_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_WidgetLookFeel_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"WidgetLookManager","CEGUI::WidgetLookManager","",tolua_collect_CEGUI__WidgetLookManager);
  #else
  tolua_cclass(tolua_S,"WidgetLookManager","CEGUI::WidgetLookManager","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"WidgetLookManager");
   tolua_function(tolua_S,"getSingleton",tolua_CEGUI_CEGUI_WidgetLookManager_getSingleton00);
   tolua_function(tolua_S,"parseLookNFeelSpecification",tolua_CEGUI_CEGUI_WidgetLookManager_parseLookNFeelSpecification00);
   tolua_function(tolua_S,"isWidgetLookAvailable",tolua_CEGUI_CEGUI_WidgetLookManager_isWidgetLookAvailable00);
   tolua_function(tolua_S,"getWidgetLook",tolua_CEGUI_CEGUI_WidgetLookManager_getWidgetLook00);
   tolua_function(tolua_S,"eraseWidgetLook",tolua_CEGUI_CEGUI_WidgetLookManager_eraseWidgetLook00);
   tolua_function(tolua_S,"addWidgetLook",tolua_CEGUI_CEGUI_WidgetLookManager_addWidgetLook00);
   tolua_function(tolua_S,"writeWidgetLookToStream",tolua_CEGUI_CEGUI_WidgetLookManager_writeWidgetLookToStream00);
   tolua_function(tolua_S,"writeWidgetLookSeriesToStream",tolua_CEGUI_CEGUI_WidgetLookManager_writeWidgetLookSeriesToStream00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_WidgetLookManager_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_WidgetLookManager_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_WidgetLookManager_new00_local);
   tolua_function(tolua_S,"setDefaultResourceGroup",tolua_CEGUI_CEGUI_WidgetLookManager_setDefaultResourceGroup00);
   tolua_function(tolua_S,"getDefaultResourceGroup",tolua_CEGUI_CEGUI_WidgetLookManager_getDefaultResourceGroup00);
  tolua_endmodule(tolua_S);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static unsigned char B[] = {
  10,102,117,110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73,
    46,116,111, 77,111,117,115,101, 67,117,114,115,111,114, 69,
   118,101,110,116, 65,114,103,115, 40,101, 41, 10,114,101,116,
   117,114,110, 32,116,111,108,117, 97, 46, 99, 97,115,116, 40,
   101, 44, 34, 99,111,110,115,116, 32, 67, 69, 71, 85, 73, 58,
    58, 77,111,117,115,101, 67,117,114,115,111,114, 69,118,101,
   110,116, 65,114,103,115, 34, 41, 10,101,110,100, 10,102,117,
   110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111,
    87,105,110,100,111,119, 69,118,101,110,116, 65,114,103,115,
    40,101, 41, 10,114,101,116,117,114,110, 32,116,111,108,117,
    97, 46, 99, 97,115,116, 40,101, 44, 34, 99,111,110,115,116,
    32, 67, 69, 71, 85, 73, 58, 58, 87,105,110,100,111,119, 69,
   118,101,110,116, 65,114,103,115, 34, 41, 10,101,110,100, 10,
   102,117,110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,
   116,111, 65, 99,116,105,118, 97,116,105,111,110, 69,118,101,
   110,116, 65,114,103,115, 40,101, 41, 10,114,101,116,117,114,
   110, 32,116,111,108,117, 97, 46, 99, 97,115,116, 40,101, 44,
    34, 99,111,110,115,116, 32, 67, 69, 71, 85, 73, 58, 58, 65,
    99,116,105,118, 97,116,105,111,110, 69,118,101,110,116, 65,
   114,103,115, 34, 41, 10,101,110,100, 10,102,117,110, 99,116,
   105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 72,101, 97,
   100,101,114, 83,101,113,117,101,110, 99,101, 69,118,101,110,
   116, 65,114,103,115, 40,101, 41, 10,114,101,116,117,114,110,
    32,116,111,108,117, 97, 46, 99, 97,115,116, 40,101, 44, 34,
    99,111,110,115,116, 32, 67, 69, 71, 85, 73, 58, 58, 72,101,
    97,100,101,114, 83,101,113,117,101,110, 99,101, 69,118,101,
   110,116, 65,114,103,115, 34, 41, 10,101,110,100, 10,102,117,
   110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111,
    77,111,117,115,101, 69,118,101,110,116, 65,114,103,115, 40,
   101, 41, 10,114,101,116,117,114,110, 32,116,111,108,117, 97,
    46, 99, 97,115,116, 40,101, 44, 34, 99,111,110,115,116, 32,
    67, 69, 71, 85, 73, 58, 58, 77,111,117,115,101, 69,118,101,
   110,116, 65,114,103,115, 34, 41, 10,101,110,100, 10,102,117,
   110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111,
    75,101,121, 69,118,101,110,116, 65,114,103,115, 40,101, 41,
    10,114,101,116,117,114,110, 32,116,111,108,117, 97, 46, 99,
    97,115,116, 40,101, 44, 34, 99,111,110,115,116, 32, 67, 69,
    71, 85, 73, 58, 58, 75,101,121, 69,118,101,110,116, 65,114,
   103,115, 34, 41, 10,101,110,100, 10,102,117,110, 99,116,105,
   111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 68,114, 97,103,
    68,114,111,112, 69,118,101,110,116, 65,114,103,115, 40,101,
    41, 10,114,101,116,117,114,110, 32,116,111,108,117, 97, 46,
    99, 97,115,116, 40,101, 44, 34, 99,111,110,115,116, 32, 67,
    69, 71, 85, 73, 58, 58, 68,114, 97,103, 68,114,111,112, 69,
   118,101,110,116, 65,114,103,115, 34, 41, 10,101,110,100, 10,
   102,117,110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,
   116,111, 84,114,101,101, 69,118,101,110,116, 65,114,103,115,
    40,101, 41, 10,114,101,116,117,114,110, 32,116,111,108,117,
    97, 46, 99, 97,115,116, 40,101, 44, 34, 99,111,110,115,116,
    32, 67, 69, 71, 85, 73, 58, 58, 84,114,101,101, 69,118,101,
   110,116, 65,114,103,115, 34, 41, 10,101,110,100, 10,102,117,
   110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111,
    82,101,110,100,101,114, 81,117,101,117,101, 69,118,101,110,
   116, 65,114,103,115, 40,101, 41, 10,114,101,116,117,114,110,
    32,116,111,108,117, 97, 46, 99, 97,115,116, 40,101, 44, 34,
    99,111,110,115,116, 32, 67, 69, 71, 85, 73, 58, 58, 82,101,
   110,100,101,114, 81,117,101,117,101, 69,118,101,110,116, 65,
   114,103,115, 34, 41, 10,101,110,100, 10, 67, 69, 71, 85, 73,
    46, 69,118,101,110,116, 65,114,103,115, 46,116,111, 77,111,
   117,115,101, 67,117,114,115,111,114, 69,118,101,110,116, 65,
   114,103,115, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,111, 77,
   111,117,115,101, 67,117,114,115,111,114, 69,118,101,110,116,
    65,114,103,115, 10, 67, 69, 71, 85, 73, 46, 69,118,101,110,
   116, 65,114,103,115, 46,116,111, 87,105,110,100,111,119, 69,
   118,101,110,116, 65,114,103,115, 32, 61, 32, 67, 69, 71, 85,
    73, 46,116,111, 87,105,110,100,111,119, 69,118,101,110,116,
    65,114,103,115, 10, 67, 69, 71, 85, 73, 46, 69,118,101,110,
   116, 65,114,103,115, 46,116,111, 65, 99,116,105,118, 97,116,
   105,111,110, 69,118,101,110,116, 65,114,103,115, 32, 61, 32,
    67, 69, 71, 85, 73, 46,116,111, 65, 99,116,105,118, 97,116,
   105,111,110, 69,118,101,110,116, 65,114,103,115, 10, 67, 69,
    71, 85, 73, 46, 69,118,101,110,116, 65,114,103,115, 46,116,
   111, 72,101, 97,100,101,114, 83,101,113,117,101,110, 99,101,
    69,118,101,110,116, 65,114,103,115, 32, 61, 32, 67, 69, 71,
    85, 73, 46,116,111, 72,101, 97,100,101,114, 83,101,113,117,
   101,110, 99,101, 69,118,101,110,116, 65,114,103,115, 10, 67,
    69, 71, 85, 73, 46, 69,118,101,110,116, 65,114,103,115, 46,
   116,111, 77,111,117,115,101, 69,118,101,110,116, 65,114,103,
   115, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,111, 77,111,117,
   115,101, 69,118,101,110,116, 65,114,103,115, 10, 67, 69, 71,
    85, 73, 46, 69,118,101,110,116, 65,114,103,115, 46,116,111,
    75,101,121, 69,118,101,110,116, 65,114,103,115, 32, 61, 32,
    67, 69, 71, 85, 73, 46,116,111, 75,101,121, 69,118,101,110,
   116, 65,114,103,115, 10, 67, 69, 71, 85, 73, 46, 69,118,101,
   110,116, 65,114,103,115, 46,116,111, 68,114, 97,103, 68,114,
   111,112, 69,118,101,110,116, 65,114,103,115, 32, 61, 32, 67,
    69, 71, 85, 73, 46,116,111, 68,114, 97,103, 68,114,111,112,
    69,118,101,110,116, 65,114,103,115, 10, 67, 69, 71, 85, 73,
    46, 69,118,101,110,116, 65,114,103,115, 46,116,111, 84,114,
   101,101, 69,118,101,110,116, 65,114,103,115, 32, 61, 32, 67,
    69, 71, 85, 73, 46,116,111, 84,114,101,101, 69,118,101,110,
   116, 65,114,103,115, 10, 67, 69, 71, 85, 73, 46, 69,118,101,
   110,116, 65,114,103,115, 46,116,111, 82,101,110,100,101,114,
    81,117,101,117,101, 69,118,101,110,116, 65,114,103,115, 32,
    61, 32, 67, 69, 71, 85, 73, 46,116,111, 82,101,110,100,101,
   114, 81,117,101,117,101, 69,118,101,110,116, 65,114,103,115,
   32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 12");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */


  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static unsigned char B[] = {
  10,102,117,110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73,
    46,116,111, 66,117,116,116,111,110, 66, 97,115,101, 40,119,
    41, 10,114,101,116,117,114,110, 32,116,111,108,117, 97, 46,
    99, 97,115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58,
    66,117,116,116,111,110, 66, 97,115,101, 34, 41, 10,101,110,
   100, 10,102,117,110, 99,116,105,111,110, 32, 67, 69, 71, 85,
    73, 46,116,111, 67,104,101, 99,107, 98,111,120, 40,119, 41,
    10,114,101,116,117,114,110, 32,116,111,108,117, 97, 46, 99,
    97,115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 67,
   104,101, 99,107, 98,111,120, 34, 41, 10,101,110,100, 10,102,
   117,110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,
   111, 67,111,109, 98,111, 98,111,120, 40,119, 41, 10,114,101,
   116,117,114,110, 32,116,111,108,117, 97, 46, 99, 97,115,116,
    40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 67,111,109, 98,
   111, 98,111,120, 34, 41, 10,101,110,100, 10,102,117,110, 99,
   116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 67,111,
   109, 98,111, 68,114,111,112, 76,105,115,116, 40,119, 41, 10,
   114,101,116,117,114,110, 32,116,111,108,117, 97, 46, 99, 97,
   115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 67,111,
   109, 98,111, 68,114,111,112, 76,105,115,116, 34, 41, 10,101,
   110,100, 10,102,117,110, 99,116,105,111,110, 32, 67, 69, 71,
    85, 73, 46,116,111, 68,114, 97,103, 67,111,110,116, 97,105,
   110,101,114, 40,119, 41, 10,114,101,116,117,114,110, 32,116,
   111,108,117, 97, 46, 99, 97,115,116, 40,119, 44, 34, 67, 69,
    71, 85, 73, 58, 58, 68,114, 97,103, 67,111,110,116, 97,105,
   110,101,114, 34, 41, 10,101,110,100, 10,102,117,110, 99,116,
   105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 69,100,105,
   116, 98,111,120, 40,119, 41, 10,114,101,116,117,114,110, 32,
   116,111,108,117, 97, 46, 99, 97,115,116, 40,119, 44, 34, 67,
    69, 71, 85, 73, 58, 58, 69,100,105,116, 98,111,120, 34, 41,
    10,101,110,100, 10,102,117,110, 99,116,105,111,110, 32, 67,
    69, 71, 85, 73, 46,116,111, 70,114, 97,109,101, 87,105,110,
   100,111,119, 40,119, 41, 10,114,101,116,117,114,110, 32,116,
   111,108,117, 97, 46, 99, 97,115,116, 40,119, 44, 34, 67, 69,
    71, 85, 73, 58, 58, 70,114, 97,109,101, 87,105,110,100,111,
   119, 34, 41, 10,101,110,100, 10,102,117,110, 99,116,105,111,
   110, 32, 67, 69, 71, 85, 73, 46,116,111, 71,114,105,100, 76,
    97,121,111,117,116, 67,111,110,116, 97,105,110,101,114, 40,
   119, 41, 10,114,101,116,117,114,110, 32,116,111,108,117, 97,
    46, 99, 97,115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58,
    58, 71,114,105,100, 76, 97,121,111,117,116, 67,111,110,116,
    97,105,110,101,114, 34, 41, 10,101,110,100, 10,102,117,110,
    99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 71,
    85, 73, 83,104,101,101,116, 40,119, 41, 10,114,101,116,117,
   114,110, 32,116,111,108,117, 97, 46, 99, 97,115,116, 40,119,
    44, 34, 67, 69, 71, 85, 73, 58, 58, 71, 85, 73, 83,104,101,
   101,116, 34, 41, 10,101,110,100, 10,102,117,110, 99,116,105,
   111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 72,111,114,105,
   122,111,110,116, 97,108, 76, 97,121,111,117,116, 67,111,110,
   116, 97,105,110,101,114, 40,119, 41, 10,114,101,116,117,114,
   110, 32,116,111,108,117, 97, 46, 99, 97,115,116, 40,119, 44,
    34, 67, 69, 71, 85, 73, 58, 58, 72,111,114,105,122,111,110,
   116, 97,108, 76, 97,121,111,117,116, 67,111,110,116, 97,105,
   110,101,114, 34, 41, 10,101,110,100, 10,102,117,110, 99,116,
   105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 73,116,101,
   109, 69,110,116,114,121, 40,119, 41, 10,114,101,116,117,114,
   110, 32,116,111,108,117, 97, 46, 99, 97,115,116, 40,119, 44,
    34, 67, 69, 71, 85, 73, 58, 58, 73,116,101,109, 69,110,116,
   114,121, 34, 41, 10,101,110,100, 10,102,117,110, 99,116,105,
   111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 73,116,101,109,
    76,105,115,116, 66, 97,115,101, 40,119, 41, 10,114,101,116,
   117,114,110, 32,116,111,108,117, 97, 46, 99, 97,115,116, 40,
   119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 73,116,101,109, 76,
   105,115,116, 66, 97,115,101, 34, 41, 10,101,110,100, 10,102,
   117,110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,
   111, 73,116,101,109, 76,105,115,116, 98,111,120, 40,119, 41,
    10,114,101,116,117,114,110, 32,116,111,108,117, 97, 46, 99,
    97,115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 73,
   116,101,109, 76,105,115,116, 98,111,120, 34, 41, 10,101,110,
   100, 10,102,117,110, 99,116,105,111,110, 32, 67, 69, 71, 85,
    73, 46,116,111, 76, 97,121,111,117,116, 67,111,110,116, 97,
   105,110,101,114, 40,119, 41, 10,114,101,116,117,114,110, 32,
   116,111,108,117, 97, 46, 99, 97,115,116, 40,119, 44, 34, 67,
    69, 71, 85, 73, 58, 58, 76, 97,121,111,117,116, 67,111,110,
   116, 97,105,110,101,114, 34, 41, 10,101,110,100, 10,102,117,
   110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111,
    76,105,115,116, 98,111,120, 40,119, 41, 10,114,101,116,117,
   114,110, 32,116,111,108,117, 97, 46, 99, 97,115,116, 40,119,
    44, 34, 67, 69, 71, 85, 73, 58, 58, 76,105,115,116, 98,111,
   120, 34, 41, 10,101,110,100, 10,102,117,110, 99,116,105,111,
   110, 32, 67, 69, 71, 85, 73, 46,116,111, 76,105,115,116, 72,
   101, 97,100,101,114, 40,119, 41, 10,114,101,116,117,114,110,
    32,116,111,108,117, 97, 46, 99, 97,115,116, 40,119, 44, 34,
    67, 69, 71, 85, 73, 58, 58, 76,105,115,116, 72,101, 97,100,
   101,114, 34, 41, 10,101,110,100, 10,102,117,110, 99,116,105,
   111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 76,105,115,116,
    72,101, 97,100,101,114, 83,101,103,109,101,110,116, 40,119,
    41, 10,114,101,116,117,114,110, 32,116,111,108,117, 97, 46,
    99, 97,115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58,
    76,105,115,116, 72,101, 97,100,101,114, 83,101,103,109,101,
   110,116, 34, 41, 10,101,110,100, 10,102,117,110, 99,116,105,
   111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 77,101,110,117,
    98, 97,114, 40,119, 41, 10,114,101,116,117,114,110, 32,116,
   111,108,117, 97, 46, 99, 97,115,116, 40,119, 44, 34, 67, 69,
    71, 85, 73, 58, 58, 77,101,110,117, 98, 97,114, 34, 41, 10,
   101,110,100, 10,102,117,110, 99,116,105,111,110, 32, 67, 69,
    71, 85, 73, 46,116,111, 77,101,110,117, 66, 97,115,101, 40,
   119, 41, 10,114,101,116,117,114,110, 32,116,111,108,117, 97,
    46, 99, 97,115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58,
    58, 77,101,110,117, 66, 97,115,101, 34, 41, 10,101,110,100,
    10,102,117,110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73,
    46,116,111, 77,101,110,117, 73,116,101,109, 40,119, 41, 10,
   114,101,116,117,114,110, 32,116,111,108,117, 97, 46, 99, 97,
   115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 77,101,
   110,117, 73,116,101,109, 34, 41, 10,101,110,100, 10,102,117,
   110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111,
    77,117,108,116,105, 67,111,108,117,109,110, 76,105,115,116,
    40,119, 41, 10,114,101,116,117,114,110, 32,116,111,108,117,
    97, 46, 99, 97,115,116, 40,119, 44, 34, 67, 69, 71, 85, 73,
    58, 58, 77,117,108,116,105, 67,111,108,117,109,110, 76,105,
   115,116, 34, 41, 10,101,110,100, 10,102,117,110, 99,116,105,
   111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 77,117,108,116,
   105, 76,105,110,101, 69,100,105,116, 98,111,120, 40,119, 41,
    10,114,101,116,117,114,110, 32,116,111,108,117, 97, 46, 99,
    97,115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 77,
   117,108,116,105, 76,105,110,101, 69,100,105,116, 98,111,120,
    34, 41, 10,101,110,100, 10,102,117,110, 99,116,105,111,110,
    32, 67, 69, 71, 85, 73, 46,116,111, 80,111,112,117,112, 77,
   101,110,117, 40,119, 41, 10,114,101,116,117,114,110, 32,116,
   111,108,117, 97, 46, 99, 97,115,116, 40,119, 44, 34, 67, 69,
    71, 85, 73, 58, 58, 80,111,112,117,112, 77,101,110,117, 34,
    41, 10,101,110,100, 10,102,117,110, 99,116,105,111,110, 32,
    67, 69, 71, 85, 73, 46,116,111, 80,114,111,103,114,101,115,
   115, 66, 97,114, 40,119, 41, 10,114,101,116,117,114,110, 32,
   116,111,108,117, 97, 46, 99, 97,115,116, 40,119, 44, 34, 67,
    69, 71, 85, 73, 58, 58, 80,114,111,103,114,101,115,115, 66,
    97,114, 34, 41, 10,101,110,100, 10,102,117,110, 99,116,105,
   111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 80,117,115,104,
    66,117,116,116,111,110, 40,119, 41, 10,114,101,116,117,114,
   110, 32,116,111,108,117, 97, 46, 99, 97,115,116, 40,119, 44,
    34, 67, 69, 71, 85, 73, 58, 58, 80,117,115,104, 66,117,116,
   116,111,110, 34, 41, 10,101,110,100, 10,102,117,110, 99,116,
   105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 82, 97,100,
   105,111, 66,117,116,116,111,110, 40,119, 41, 10,114,101,116,
   117,114,110, 32,116,111,108,117, 97, 46, 99, 97,115,116, 40,
   119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 82, 97,100,105,111,
    66,117,116,116,111,110, 34, 41, 10,101,110,100, 10,102,117,
   110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111,
    83, 99,114,111,108,108, 97, 98,108,101, 80, 97,110,101, 40,
   119, 41, 10,114,101,116,117,114,110, 32,116,111,108,117, 97,
    46, 99, 97,115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58,
    58, 83, 99,114,111,108,108, 97, 98,108,101, 80, 97,110,101,
    34, 41, 10,101,110,100, 10,102,117,110, 99,116,105,111,110,
    32, 67, 69, 71, 85, 73, 46,116,111, 83, 99,114,111,108,108,
    98, 97,114, 40,119, 41, 10,114,101,116,117,114,110, 32,116,
   111,108,117, 97, 46, 99, 97,115,116, 40,119, 44, 34, 67, 69,
    71, 85, 73, 58, 58, 83, 99,114,111,108,108, 98, 97,114, 34,
    41, 10,101,110,100, 10,102,117,110, 99,116,105,111,110, 32,
    67, 69, 71, 85, 73, 46,116,111, 83, 99,114,111,108,108,101,
   100, 67,111,110,116, 97,105,110,101,114, 40,119, 41, 10,114,
   101,116,117,114,110, 32,116,111,108,117, 97, 46, 99, 97,115,
   116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 83, 99,114,
   111,108,108,101,100, 67,111,110,116, 97,105,110,101,114, 34,
    41, 10,101,110,100, 10,102,117,110, 99,116,105,111,110, 32,
    67, 69, 71, 85, 73, 46,116,111, 83, 99,114,111,108,108,101,
   100, 73,116,101,109, 76,105,115,116, 66, 97,115,101, 40,119,
    41, 10,114,101,116,117,114,110, 32,116,111,108,117, 97, 46,
    99, 97,115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58,
    83, 99,114,111,108,108,101,100, 73,116,101,109, 76,105,115,
   116, 66, 97,115,101, 34, 41, 10,101,110,100, 10,102,117,110,
    99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 83,
   101,113,117,101,110,116,105, 97,108, 76, 97,121,111,117,116,
    67,111,110,116, 97,105,110,101,114, 40,119, 41, 10,114,101,
   116,117,114,110, 32,116,111,108,117, 97, 46, 99, 97,115,116,
    40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 83,101,113,117,
   101,110,116,105, 97,108, 76, 97,121,111,117,116, 67,111,110,
   116, 97,105,110,101,114, 34, 41, 10,101,110,100, 10,102,117,
   110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111,
    83,108,105,100,101,114, 40,119, 41, 10,114,101,116,117,114,
   110, 32,116,111,108,117, 97, 46, 99, 97,115,116, 40,119, 44,
    34, 67, 69, 71, 85, 73, 58, 58, 83,108,105,100,101,114, 34,
    41, 10,101,110,100, 10,102,117,110, 99,116,105,111,110, 32,
    67, 69, 71, 85, 73, 46,116,111, 83,112,105,110,110,101,114,
    40,119, 41, 10,114,101,116,117,114,110, 32,116,111,108,117,
    97, 46, 99, 97,115,116, 40,119, 44, 34, 67, 69, 71, 85, 73,
    58, 58, 83,112,105,110,110,101,114, 34, 41, 10,101,110,100,
    10,102,117,110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73,
    46,116,111, 84, 97, 98, 66,117,116,116,111,110, 40,119, 41,
    10,114,101,116,117,114,110, 32,116,111,108,117, 97, 46, 99,
    97,115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 84,
    97, 98, 66,117,116,116,111,110, 34, 41, 10,101,110,100, 10,
   102,117,110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,
   116,111, 84, 97, 98, 67,111,110,116,114,111,108, 40,119, 41,
    10,114,101,116,117,114,110, 32,116,111,108,117, 97, 46, 99,
    97,115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 84,
    97, 98, 67,111,110,116,114,111,108, 34, 41, 10,101,110,100,
    10,102,117,110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73,
    46,116,111, 84, 97, 98, 80, 97,110,101, 40,119, 41, 10,114,
   101,116,117,114,110, 32,116,111,108,117, 97, 46, 99, 97,115,
   116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 84, 97, 98,
    80, 97,110,101, 34, 41, 10,101,110,100, 10,102,117,110, 99,
   116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 84,104,
   117,109, 98, 40,119, 41, 10,114,101,116,117,114,110, 32,116,
   111,108,117, 97, 46, 99, 97,115,116, 40,119, 44, 34, 67, 69,
    71, 85, 73, 58, 58, 84,104,117,109, 98, 34, 41, 10,101,110,
   100, 10,102,117,110, 99,116,105,111,110, 32, 67, 69, 71, 85,
    73, 46,116,111, 84,111,111,108,116,105,112, 40,119, 41, 10,
   114,101,116,117,114,110, 32,116,111,108,117, 97, 46, 99, 97,
   115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 84,111,
   111,108,116,105,112, 34, 41, 10,101,110,100, 10,102,117,110,
    99,116,105,111,110, 32, 67, 69, 71, 85, 73, 46,116,111, 84,
   114,101,101, 40,119, 41, 10,114,101,116,117,114,110, 32,116,
   111,108,117, 97, 46, 99, 97,115,116, 40,119, 44, 34, 67, 69,
    71, 85, 73, 58, 58, 84,114,101,101, 34, 41, 10,101,110,100,
    10,102,117,110, 99,116,105,111,110, 32, 67, 69, 71, 85, 73,
    46,116,111, 86,101,114,116,105, 99, 97,108, 76, 97,121,111,
   117,116, 67,111,110,116, 97,105,110,101,114, 40,119, 41, 10,
   114,101,116,117,114,110, 32,116,111,108,117, 97, 46, 99, 97,
   115,116, 40,119, 44, 34, 67, 69, 71, 85, 73, 58, 58, 86,101,
   114,116,105, 99, 97,108, 76, 97,121,111,117,116, 67,111,110,
   116, 97,105,110,101,114, 34, 41, 10,101,110,100, 10, 67, 69,
    71, 85, 73, 46, 87,105,110,100,111,119, 46,116,111, 66,117,
   116,116,111,110, 66, 97,115,101, 32, 61, 32, 67, 69, 71, 85,
    73, 46,116,111, 66,117,116,116,111,110, 66, 97,115,101, 10,
    67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,116,111,
    67,104,101, 99,107, 98,111,120, 32, 61, 32, 67, 69, 71, 85,
    73, 46,116,111, 67,104,101, 99,107, 98,111,120, 10, 67, 69,
    71, 85, 73, 46, 87,105,110,100,111,119, 46,116,111, 67,111,
   109, 98,111, 98,111,120, 32, 61, 32, 67, 69, 71, 85, 73, 46,
   116,111, 67,111,109, 98,111, 98,111,120, 10, 67, 69, 71, 85,
    73, 46, 87,105,110,100,111,119, 46,116,111, 67,111,109, 98,
   111, 68,114,111,112, 76,105,115,116, 32, 61, 32, 67, 69, 71,
    85, 73, 46,116,111, 67,111,109, 98,111, 68,114,111,112, 76,
   105,115,116, 10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,
   119, 46,116,111, 68,114, 97,103, 67,111,110,116, 97,105,110,
   101,114, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,111, 68,114,
    97,103, 67,111,110,116, 97,105,110,101,114, 10, 67, 69, 71,
    85, 73, 46, 87,105,110,100,111,119, 46,116,111, 69,100,105,
   116, 98,111,120, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,111,
    69,100,105,116, 98,111,120, 10, 67, 69, 71, 85, 73, 46, 87,
   105,110,100,111,119, 46,116,111, 70,114, 97,109,101, 87,105,
   110,100,111,119, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,111,
    70,114, 97,109,101, 87,105,110,100,111,119, 10, 67, 69, 71,
    85, 73, 46, 87,105,110,100,111,119, 46,116,111, 71,114,105,
   100, 76, 97,121,111,117,116, 67,111,110,116, 97,105,110,101,
   114, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,111, 71,114,105,
   100, 76, 97,121,111,117,116, 67,111,110,116, 97,105,110,101,
   114, 10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,
   116,111, 71, 85, 73, 83,104,101,101,116, 32, 61, 32, 67, 69,
    71, 85, 73, 46,116,111, 71, 85, 73, 83,104,101,101,116, 10,
    67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,116,111,
    72,111,114,105,122,111,110,116, 97,108, 76, 97,121,111,117,
   116, 67,111,110,116, 97,105,110,101,114, 32, 61, 32, 67, 69,
    71, 85, 73, 46,116,111, 72,111,114,105,122,111,110,116, 97,
   108, 76, 97,121,111,117,116, 67,111,110,116, 97,105,110,101,
   114, 10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,
   116,111, 73,116,101,109, 69,110,116,114,121, 32, 61, 32, 67,
    69, 71, 85, 73, 46,116,111, 73,116,101,109, 69,110,116,114,
   121, 10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,
   116,111, 73,116,101,109, 76,105,115,116, 66, 97,115,101, 32,
    61, 32, 67, 69, 71, 85, 73, 46,116,111, 73,116,101,109, 76,
   105,115,116, 66, 97,115,101, 10, 67, 69, 71, 85, 73, 46, 87,
   105,110,100,111,119, 46,116,111, 73,116,101,109, 76,105,115,
   116, 98,111,120, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,111,
    73,116,101,109, 76,105,115,116, 98,111,120, 10, 67, 69, 71,
    85, 73, 46, 87,105,110,100,111,119, 46,116,111, 76, 97,121,
   111,117,116, 67,111,110,116, 97,105,110,101,114, 32, 61, 32,
    67, 69, 71, 85, 73, 46,116,111, 76, 97,121,111,117,116, 67,
   111,110,116, 97,105,110,101,114, 10, 67, 69, 71, 85, 73, 46,
    87,105,110,100,111,119, 46,116,111, 76,105,115,116, 98,111,
   120, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,111, 76,105,115,
   116, 98,111,120, 10, 67, 69, 71, 85, 73, 46, 87,105,110,100,
   111,119, 46,116,111, 76,105,115,116, 72,101, 97,100,101,114,
    32, 61, 32, 67, 69, 71, 85, 73, 46,116,111, 76,105,115,116,
    72,101, 97,100,101,114, 10, 67, 69, 71, 85, 73, 46, 87,105,
   110,100,111,119, 46,116,111, 76,105,115,116, 72,101, 97,100,
   101,114, 83,101,103,109,101,110,116, 32, 61, 32, 67, 69, 71,
    85, 73, 46,116,111, 76,105,115,116, 72,101, 97,100,101,114,
    83,101,103,109,101,110,116, 10, 67, 69, 71, 85, 73, 46, 87,
   105,110,100,111,119, 46,116,111, 77,101,110,117, 98, 97,114,
    32, 61, 32, 67, 69, 71, 85, 73, 46,116,111, 77,101,110,117,
    98, 97,114, 10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,
   119, 46,116,111, 77,101,110,117, 66, 97,115,101, 32, 61, 32,
    67, 69, 71, 85, 73, 46,116,111, 77,101,110,117, 66, 97,115,
   101, 10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,
   116,111, 77,101,110,117, 73,116,101,109, 32, 61, 32, 67, 69,
    71, 85, 73, 46,116,111, 77,101,110,117, 73,116,101,109, 10,
    67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,116,111,
    77,117,108,116,105, 67,111,108,117,109,110, 76,105,115,116,
    32, 61, 32, 67, 69, 71, 85, 73, 46,116,111, 77,117,108,116,
   105, 67,111,108,117,109,110, 76,105,115,116, 10, 67, 69, 71,
    85, 73, 46, 87,105,110,100,111,119, 46,116,111, 77,117,108,
   116,105, 76,105,110,101, 69,100,105,116, 98,111,120, 32, 61,
    32, 67, 69, 71, 85, 73, 46,116,111, 77,117,108,116,105, 76,
   105,110,101, 69,100,105,116, 98,111,120, 10, 67, 69, 71, 85,
    73, 46, 87,105,110,100,111,119, 46,116,111, 80,111,112,117,
   112, 77,101,110,117, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,
   111, 80,111,112,117,112, 77,101,110,117, 10, 67, 69, 71, 85,
    73, 46, 87,105,110,100,111,119, 46,116,111, 80,114,111,103,
   114,101,115,115, 66, 97,114, 32, 61, 32, 67, 69, 71, 85, 73,
    46,116,111, 80,114,111,103,114,101,115,115, 66, 97,114, 10,
    67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,116,111,
    80,117,115,104, 66,117,116,116,111,110, 32, 61, 32, 67, 69,
    71, 85, 73, 46,116,111, 80,117,115,104, 66,117,116,116,111,
   110, 10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,
   116,111, 82, 97,100,105,111, 66,117,116,116,111,110, 32, 61,
    32, 67, 69, 71, 85, 73, 46,116,111, 82, 97,100,105,111, 66,
   117,116,116,111,110, 10, 67, 69, 71, 85, 73, 46, 87,105,110,
   100,111,119, 46,116,111, 83, 99,114,111,108,108, 97, 98,108,
   101, 80, 97,110,101, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,
   111, 83, 99,114,111,108,108, 97, 98,108,101, 80, 97,110,101,
    10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,116,
   111, 83, 99,114,111,108,108, 98, 97,114, 32, 61, 32, 67, 69,
    71, 85, 73, 46,116,111, 83, 99,114,111,108,108, 98, 97,114,
    10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,116,
   111, 83, 99,114,111,108,108,101,100, 67,111,110,116, 97,105,
   110,101,114, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,111, 83,
    99,114,111,108,108,101,100, 67,111,110,116, 97,105,110,101,
   114, 10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,
   116,111, 83, 99,114,111,108,108,101,100, 73,116,101,109, 76,
   105,115,116, 66, 97,115,101, 32, 61, 32, 67, 69, 71, 85, 73,
    46,116,111, 83, 99,114,111,108,108,101,100, 73,116,101,109,
    76,105,115,116, 66, 97,115,101, 10, 67, 69, 71, 85, 73, 46,
    87,105,110,100,111,119, 46,116,111, 83,101,113,117,101,110,
   116,105, 97,108, 76, 97,121,111,117,116, 67,111,110,116, 97,
   105,110,101,114, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,111,
    83,101,113,117,101,110,116,105, 97,108, 76, 97,121,111,117,
   116, 67,111,110,116, 97,105,110,101,114, 10, 67, 69, 71, 85,
    73, 46, 87,105,110,100,111,119, 46,116,111, 83,108,105,100,
   101,114, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,111, 83,108,
   105,100,101,114, 10, 67, 69, 71, 85, 73, 46, 87,105,110,100,
   111,119, 46,116,111, 83,112,105,110,110,101,114, 32, 61, 32,
    67, 69, 71, 85, 73, 46,116,111, 83,112,105,110,110,101,114,
    10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,116,
   111, 84, 97, 98, 66,117,116,116,111,110, 32, 61, 32, 67, 69,
    71, 85, 73, 46,116,111, 84, 97, 98, 66,117,116,116,111,110,
    10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,116,
   111, 84, 97, 98, 67,111,110,116,114,111,108, 32, 61, 32, 67,
    69, 71, 85, 73, 46,116,111, 84, 97, 98, 67,111,110,116,114,
   111,108, 10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119,
    46,116,111, 84, 97, 98, 80, 97,110,101, 32, 61, 32, 67, 69,
    71, 85, 73, 46,116,111, 84, 97, 98, 80, 97,110,101, 10, 67,
    69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,116,111, 84,
   104,117,109, 98, 32, 61, 32, 67, 69, 71, 85, 73, 46,116,111,
    84,104,117,109, 98, 10, 67, 69, 71, 85, 73, 46, 87,105,110,
   100,111,119, 46,116,111, 84,111,111,108,116,105,112, 32, 61,
    32, 67, 69, 71, 85, 73, 46,116,111, 84,111,111,108,116,105,
   112, 10, 67, 69, 71, 85, 73, 46, 87,105,110,100,111,119, 46,
   116,111, 84,114,101,101, 32, 61, 32, 67, 69, 71, 85, 73, 46,
   116,111, 84,114,101,101, 10, 67, 69, 71, 85, 73, 46, 87,105,
   110,100,111,119, 46,116,111, 86,101,114,116,105, 99, 97,108,
    76, 97,121,111,117,116, 67,111,110,116, 97,105,110,101,114,
    32, 61, 32, 67, 69, 71, 85, 73, 46,116,111, 86,101,114,116,
   105, 99, 97,108, 76, 97,121,111,117,116, 67,111,110,116, 97,
   105,110,101,114,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 13");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  tolua_function(tolua_S,"createListboxTextItem",tolua_CEGUI_CEGUI_createListboxTextItem00);
  tolua_function(tolua_S,"createTreeItem",tolua_CEGUI_CEGUI_createTreeItem00);
  tolua_cclass(tolua_S,"OutStream","CEGUI::OutStream","",NULL);
  tolua_beginmodule(tolua_S,"OutStream");
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"FileStream","CEGUI::FileStream","CEGUI::OutStream",tolua_collect_CEGUI__FileStream);
  #else
  tolua_cclass(tolua_S,"FileStream","CEGUI::FileStream","CEGUI::OutStream",NULL);
  #endif
  tolua_beginmodule(tolua_S,"FileStream");
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_FileStream_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_FileStream_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_FileStream_new00_local);
   tolua_function(tolua_S,"is_open",tolua_CEGUI_CEGUI_FileStream_is_open00);
   tolua_function(tolua_S,"open",tolua_CEGUI_CEGUI_FileStream_open00);
   tolua_function(tolua_S,"close",tolua_CEGUI_CEGUI_FileStream_close00);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 int luaopen_CEGUI (lua_State* tolua_S) {
 return tolua_CEGUI_open(tolua_S);
};
#endif

