/*
** Lua binding: CEGUI
** Generated automatically by tolua++-1.0.93 on Sun Jun 15 09:22:26 2014.
*/

#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 "CEGUI/PropertyHelper.h"

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

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__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__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__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__ImagePair (lua_State* tolua_S)
{
 CEGUI::ImagePair* self = (CEGUI::ImagePair*) 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__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__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__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__ElementEventArgs (lua_State* tolua_S)
{
 CEGUI::ElementEventArgs* self = (CEGUI::ElementEventArgs*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__Rect_float_ (lua_State* tolua_S)
{
 CEGUI::Rect<float>* self = (CEGUI::Rect<float>*) 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__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__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__NamedElement (lua_State* tolua_S)
{
 CEGUI::NamedElement* self = (CEGUI::NamedElement*) 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__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__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__GUIContextEventArgs (lua_State* tolua_S)
{
 CEGUI::GUIContextEventArgs* self = (CEGUI::GUIContextEventArgs*) 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__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__RegexMatchStateEventArgs (lua_State* tolua_S)
{
 CEGUI::RegexMatchStateEventArgs* self = (CEGUI::RegexMatchStateEventArgs*) 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__Element (lua_State* tolua_S)
{
 CEGUI::Element* self = (CEGUI::Element*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

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

static int tolua_collect_CEGUI__Size_float_ (lua_State* tolua_S)
{
 CEGUI::Size<float>* self = (CEGUI::Size<float>*) 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__USize (lua_State* tolua_S)
{
 CEGUI::USize* self = (CEGUI::USize*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

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

static int tolua_collect_CEGUI__Vector3_float_ (lua_State* tolua_S)
{
 CEGUI::Vector3<float>* self = (CEGUI::Vector3<float>*) 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__RenderTargetEventArgs (lua_State* tolua_S)
{
 CEGUI::RenderTargetEventArgs* self = (CEGUI::RenderTargetEventArgs*) tolua_tousertype(tolua_S,1,0);
 delete self;
 return 0;
}

static int tolua_collect_CEGUI__Quaternion (lua_State* tolua_S)
{
 CEGUI::Quaternion* self = (CEGUI::Quaternion*) 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__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__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__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__NamedElementEventArgs (lua_State* tolua_S)
{
 CEGUI::NamedElementEventArgs* self = (CEGUI::NamedElementEventArgs*) 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__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__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__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__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__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__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__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__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__OperatorDim (lua_State* tolua_S)
{
 CEGUI::OperatorDim* self = (CEGUI::OperatorDim*) 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__SimpleTimer (lua_State* tolua_S)
{
 CEGUI::SimpleTimer* self = (CEGUI::SimpleTimer*) 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__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__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__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__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__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__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__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__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__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__WindowEventArgs (lua_State* tolua_S)
{
 CEGUI::WindowEventArgs* self = (CEGUI::WindowEventArgs*) 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::BasicImage");
 tolua_usertype(tolua_S,"CEGUI::TreeItem");
 tolua_usertype(tolua_S,"CEGUI::ImagePair");
 tolua_usertype(tolua_S,"CEGUI::WindowFactory");
 tolua_usertype(tolua_S,"CEGUI::MouseCursor");
 tolua_usertype(tolua_S,"CEGUI::WidgetLookManager");
 tolua_usertype(tolua_S,"CEGUI::FrameWindow");
 tolua_usertype(tolua_S,"CEGUI::EventConnection");
 tolua_usertype(tolua_S,"CEGUI::ElementEventArgs");
 tolua_usertype(tolua_S,"CEGUI::EventIterator");
 tolua_usertype(tolua_S,"CEGUI::WindowFactoryIterator");
 tolua_usertype(tolua_S,"CEGUI::ToggleButton");
 tolua_usertype(tolua_S,"CEGUI::AnimationManager");
 tolua_usertype(tolua_S,"CEGUI::UVector2");
 tolua_usertype(tolua_S,"CEGUI::Vertex");
 tolua_usertype(tolua_S,"CEGUI::GUIContextEventArgs");
 tolua_usertype(tolua_S,"CEGUI::Spinner");
 tolua_usertype(tolua_S,"CEGUI::RenderQueueEventArgs");
 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::ImageManager");
 tolua_usertype(tolua_S,"CEGUI::LayoutContainer");
 tolua_usertype(tolua_S,"CEGUI::RenderingWindow");
 tolua_usertype(tolua_S,"CEGUI::SimpleTimer");
 tolua_usertype(tolua_S,"CEGUI::WindowManager");
 tolua_usertype(tolua_S,"CEGUI::Vector2<float>");
 tolua_usertype(tolua_S,"CEGUI::WidgetLookFeel");
 tolua_usertype(tolua_S,"CEGUI::RenderTargetEventArgs");
 tolua_usertype(tolua_S,"CEGUI::ColourRect");
 tolua_usertype(tolua_S,"CEGUI::StateImagery");
 tolua_usertype(tolua_S,"CEGUI::GeometryBuffer");
 tolua_usertype(tolua_S,"CEGUI::String");
 tolua_usertype(tolua_S,"CEGUI::StringTranscoder");
 tolua_usertype(tolua_S,"CEGUI::VerticalLayoutContainer");
 tolua_usertype(tolua_S,"CEGUI::NamedElementEventArgs");
 tolua_usertype(tolua_S,"CEGUI::WindowIterator");
 tolua_usertype(tolua_S,"CEGUI::Font");
 tolua_usertype(tolua_S,"CEGUI::FontIterator");
 tolua_usertype(tolua_S,"CEGUI::ActivationEventArgs");
 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::OperatorDim");
 tolua_usertype(tolua_S,"CEGUI::KeyFrame");
 tolua_usertype(tolua_S,"CEGUI::URect");
 tolua_usertype(tolua_S,"CEGUI::ceguiLua_PropertyHelper");
 tolua_usertype(tolua_S,"CEGUI::RenderingSurface");
 tolua_usertype(tolua_S,"CEGUI::RenderTarget");
 tolua_usertype(tolua_S,"CEGUI::Slider");
 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::MouseEventArgs");
 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::Element::CachedRectf");
 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::Rect<float>");
 tolua_usertype(tolua_S,"CEGUI::GroupBox");
 tolua_usertype(tolua_S,"CEGUI::UBox");
 tolua_usertype(tolua_S,"CEGUI::FileStream");
 tolua_usertype(tolua_S,"CEGUI::NamedElement");
 tolua_usertype(tolua_S,"CEGUI::ImagerySection");
 tolua_usertype(tolua_S,"CEGUI::ProgressBar");
 tolua_usertype(tolua_S,"CEGUI::TextureTarget");
 tolua_usertype(tolua_S,"CEGUI::Tree");
 tolua_usertype(tolua_S,"CEGUI::OutStream");
 tolua_usertype(tolua_S,"CEGUI::LayerSpecification");
 tolua_usertype(tolua_S,"CEGUI::SectionSpecification");
 tolua_usertype(tolua_S,"CEGUI::HorizontalLayoutContainer");
 tolua_usertype(tolua_S,"CEGUI::RegexMatchStateEventArgs");
 tolua_usertype(tolua_S,"CEGUI::KeyEventArgs");
 tolua_usertype(tolua_S,"CEGUI::Element");
 tolua_usertype(tolua_S,"CEGUI::TextComponent");
 tolua_usertype(tolua_S,"CEGUI::TabControl");
 tolua_usertype(tolua_S,"CEGUI::FrameComponent");
 tolua_usertype(tolua_S,"CEGUI::GlobalEventSet");
 tolua_usertype(tolua_S,"CEGUI::PropertyInitialiser");
 tolua_usertype(tolua_S,"CEGUI::MCLGridRef");
 tolua_usertype(tolua_S,"CEGUI::MultiLineEditbox");
 tolua_usertype(tolua_S,"CEGUI::PropertyDim");
 tolua_usertype(tolua_S,"CEGUI::MultiColumnList");
 tolua_usertype(tolua_S,"CEGUI::ImagePropertyDim");
 tolua_usertype(tolua_S,"CEGUI::Size<float>");
 tolua_usertype(tolua_S,"CEGUI::Colour");
 tolua_usertype(tolua_S,"CEGUI::ImageDimBase");
 tolua_usertype(tolua_S,"CEGUI::Affector");
 tolua_usertype(tolua_S,"CEGUI::FontManager");
 tolua_usertype(tolua_S,"CEGUI::BaseDim");
 tolua_usertype(tolua_S,"CEGUI::GridLayoutContainer");
 tolua_usertype(tolua_S,"CEGUI::Vector3<float>");
 tolua_usertype(tolua_S,"CEGUI::Animation");
 tolua_usertype(tolua_S,"CEGUI::PushButton");
 tolua_usertype(tolua_S,"CEGUI::RenderQueue");
 tolua_usertype(tolua_S,"CEGUI::SequentialLayoutContainer");
 tolua_usertype(tolua_S,"CEGUI::Combobox");
 tolua_usertype(tolua_S,"CEGUI::GUIContext");
 tolua_usertype(tolua_S,"CEGUI::PopupMenu");
 tolua_usertype(tolua_S,"CEGUI::MouseCursorEventArgs");
 tolua_usertype(tolua_S,"CEGUI::Quaternion");
 tolua_usertype(tolua_S,"CEGUI::ImageFactory");
 tolua_usertype(tolua_S,"CEGUI::Listbox");
 tolua_usertype(tolua_S,"CEGUI::ScrolledItemListBase");
 tolua_usertype(tolua_S,"CEGUI::System");
 tolua_usertype(tolua_S,"CEGUI::MenuItem");
 tolua_usertype(tolua_S,"CEGUI::ListboxTextItem");
 tolua_usertype(tolua_S,"CEGUI::Menubar");
 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::ListHeader");
 tolua_usertype(tolua_S,"CEGUI::Property");
 tolua_usertype(tolua_S,"CEGUI::WindowEventArgs");
 tolua_usertype(tolua_S,"CEGUI::ListHeaderSegment");
 tolua_usertype(tolua_S,"CEGUI::ComponentArea");
 tolua_usertype(tolua_S,"CEGUI::WindowFactoryManager");
 tolua_usertype(tolua_S,"CEGUI::Editbox");
 tolua_usertype(tolua_S,"CEGUI::Thumb");
 tolua_usertype(tolua_S,"CEGUI::ScrolledContainer");
 tolua_usertype(tolua_S,"CEGUI::USize");
 tolua_usertype(tolua_S,"CEGUI::ImageDim");
 tolua_usertype(tolua_S,"CEGUI::SchemeManager");
 tolua_usertype(tolua_S,"CEGUI::DragContainer");
 tolua_usertype(tolua_S,"CEGUI::EventSet");
 tolua_usertype(tolua_S,"CEGUI::Titlebar");
 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::RegexMatcher");
 tolua_usertype(tolua_S,"CEGUI::TreeEventArgs");
 tolua_usertype(tolua_S,"CEGUI::CoordConverter");
 tolua_usertype(tolua_S,"CEGUI::AnimationInstance");
 tolua_usertype(tolua_S,"CEGUI::GUISheet");
 tolua_usertype(tolua_S,"CEGUI::FalagardWindowMapping");
 tolua_usertype(tolua_S,"CEGUI::UDim");
 tolua_usertype(tolua_S,"CEGUI::Interpolator");
 tolua_usertype(tolua_S,"CEGUI::Texture");
 tolua_usertype(tolua_S,"CEGUI::SystemKeys");
 tolua_usertype(tolua_S,"CEGUI::RenderingContext");
}

/* get function: d_x of class  CEGUI::Vector2<float> */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Vector2_float__x
static int tolua_get_CEGUI__Vector2_float__x(lua_State* tolua_S)
{
  CEGUI::Vector2<float>* self = (CEGUI::Vector2<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Vector2_float__x
static int tolua_set_CEGUI__Vector2_float__x(lua_State* tolua_S)
{
  CEGUI::Vector2<float>* self = (CEGUI::Vector2<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Vector2_float__y
static int tolua_get_CEGUI__Vector2_float__y(lua_State* tolua_S)
{
  CEGUI::Vector2<float>* self = (CEGUI::Vector2<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Vector2_float__y
static int tolua_set_CEGUI__Vector2_float__y(lua_State* tolua_S)
{
  CEGUI::Vector2<float>* self = (CEGUI::Vector2<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2f__add00
static int tolua_CEGUI_CEGUI_Vector2f__add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Vector2<float>* self = (const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2<float>* vec = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'",NULL);
#endif
 {
  CEGUI::Vector2<float> tolua_ret = (CEGUI::Vector2<float>)  self->operator+(*vec);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2f__sub00
static int tolua_CEGUI_CEGUI_Vector2f__sub00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Vector2<float>* self = (const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2<float>* vec = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'",NULL);
#endif
 {
  CEGUI::Vector2<float> tolua_ret = (CEGUI::Vector2<float>)  self->operator-(*vec);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2f__mul00
static int tolua_CEGUI_CEGUI_Vector2f__mul00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Vector2<float>* self = (const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2<float>* vec = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
#endif
 {
  CEGUI::Vector2<float> tolua_ret = (CEGUI::Vector2<float>)  self->operator*(*vec);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2f__eq00
static int tolua_CEGUI_CEGUI_Vector2f__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Vector2<float>* self = (const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2<float>* vec = ((const CEGUI::Vector2<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2f_new00
static int tolua_CEGUI_CEGUI_Vector2f_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Vector2<float>* tolua_ret = (CEGUI::Vector2<float>*)  new CEGUI::Vector2<float>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Vector2<float>");
 }
 }
 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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2f_new00_local
static int tolua_CEGUI_CEGUI_Vector2f_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Vector2<float>* tolua_ret = (CEGUI::Vector2<float>*)  new CEGUI::Vector2<float>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Vector2<float>");
 }
 }
 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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2f_new01
static int tolua_CEGUI_CEGUI_Vector2f_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector2<float>",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<float>* tolua_ret = (CEGUI::Vector2<float>*)  new CEGUI::Vector2<float>(x,y);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Vector2<float>");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Vector2f_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::Vector2<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector2f_new01_local
static int tolua_CEGUI_CEGUI_Vector2f_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector2<float>",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<float>* tolua_ret = (CEGUI::Vector2<float>*)  new CEGUI::Vector2<float>(x,y);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Vector2<float>");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Vector2f_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_x of class  CEGUI::Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Vector3_float__x
static int tolua_get_CEGUI__Vector3_float__x(lua_State* tolua_S)
{
  CEGUI::Vector3<float>* self = (CEGUI::Vector3<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Vector3_float__x
static int tolua_set_CEGUI__Vector3_float__x(lua_State* tolua_S)
{
  CEGUI::Vector3<float>* self = (CEGUI::Vector3<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Vector3_float__y
static int tolua_get_CEGUI__Vector3_float__y(lua_State* tolua_S)
{
  CEGUI::Vector3<float>* self = (CEGUI::Vector3<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Vector3_float__y
static int tolua_set_CEGUI__Vector3_float__y(lua_State* tolua_S)
{
  CEGUI::Vector3<float>* self = (CEGUI::Vector3<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Vector3_float__z
static int tolua_get_CEGUI__Vector3_float__z(lua_State* tolua_S)
{
  CEGUI::Vector3<float>* self = (CEGUI::Vector3<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Vector3_float__z
static int tolua_set_CEGUI__Vector3_float__z(lua_State* tolua_S)
{
  CEGUI::Vector3<float>* self = (CEGUI::Vector3<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector3f__eq00
static int tolua_CEGUI_CEGUI_Vector3f__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Vector3<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector3<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Vector3<float>* self = (const CEGUI::Vector3<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector3<float>* vec = ((const CEGUI::Vector3<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector3f_new00
static int tolua_CEGUI_CEGUI_Vector3f_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector3<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Vector3<float>* tolua_ret = (CEGUI::Vector3<float>*)  new CEGUI::Vector3<float>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Vector3<float>");
 }
 }
 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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector3f_new00_local
static int tolua_CEGUI_CEGUI_Vector3f_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector3<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Vector3<float>* tolua_ret = (CEGUI::Vector3<float>*)  new CEGUI::Vector3<float>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Vector3<float>");
 }
 }
 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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector3f_new01
static int tolua_CEGUI_CEGUI_Vector3f_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector3<float>",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<float>* tolua_ret = (CEGUI::Vector3<float>*)  new CEGUI::Vector3<float>(x,y,z);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Vector3<float>");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Vector3f_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Vector3f_new01_local
static int tolua_CEGUI_CEGUI_Vector3f_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Vector3<float>",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<float>* tolua_ret = (CEGUI::Vector3<float>*)  new CEGUI::Vector3<float>(x,y,z);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Vector3<float>");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Vector3f_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_width of class  CEGUI::Size<float> */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Size_float__width
static int tolua_get_CEGUI__Size_float__width(lua_State* tolua_S)
{
  CEGUI::Size<float>* self = (CEGUI::Size<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Size_float__width
static int tolua_set_CEGUI__Size_float__width(lua_State* tolua_S)
{
  CEGUI::Size<float>* self = (CEGUI::Size<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Size_float__height
static int tolua_get_CEGUI__Size_float__height(lua_State* tolua_S)
{
  CEGUI::Size<float>* self = (CEGUI::Size<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Size_float__height
static int tolua_set_CEGUI__Size_float__height(lua_State* tolua_S)
{
  CEGUI::Size<float>* self = (CEGUI::Size<float>*)  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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Sizef__eq00
static int tolua_CEGUI_CEGUI_Sizef__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Size<float>* self = (const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size<float>* sz = ((const CEGUI::Size<float>*)  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: clamp of class  CEGUI::Size<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Sizef_clamp00
static int tolua_CEGUI_CEGUI_Sizef_clamp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Size<float>* self = (CEGUI::Size<float>*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Size<float> min = *((CEGUI::Size<float>*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Size<float> max = *((CEGUI::Size<float>*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clamp'",NULL);
#endif
 {
  self->clamp(min,max);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clamp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: scaleToAspect of class  CEGUI::Size<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Sizef_scaleToAspect00
static int tolua_CEGUI_CEGUI_Sizef_scaleToAspect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Size<float>",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::Size<float>* self = (CEGUI::Size<float>*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::AspectMode mode = ((CEGUI::AspectMode) (int)  tolua_tonumber(tolua_S,2,0));
  float ratio = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'scaleToAspect'",NULL);
#endif
 {
  self->scaleToAspect(mode,ratio);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'scaleToAspect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::Size<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Sizef_new00
static int tolua_CEGUI_CEGUI_Sizef_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Size<float>* tolua_ret = (CEGUI::Size<float>*)  new CEGUI::Size<float>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Size<float>");
 }
 }
 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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Sizef_new00_local
static int tolua_CEGUI_CEGUI_Sizef_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Size<float>* tolua_ret = (CEGUI::Size<float>*)  new CEGUI::Size<float>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Size<float>");
 }
 }
 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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Sizef_new01
static int tolua_CEGUI_CEGUI_Sizef_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Size<float>",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<float>* tolua_ret = (CEGUI::Size<float>*)  new CEGUI::Size<float>(w,h);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Size<float>");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Sizef_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::Size<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Sizef_new01_local
static int tolua_CEGUI_CEGUI_Sizef_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Size<float>",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<float>* tolua_ret = (CEGUI::Size<float>*)  new CEGUI::Size<float>(w,h);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Size<float>");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Sizef_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_min of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Rect_float__min
static int tolua_get_CEGUI__Rect_float__min(lua_State* tolua_S)
{
  CEGUI::Rect<float>* self = (CEGUI::Rect<float>*)  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::Vector2<float>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_min of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Rect_float__min
static int tolua_set_CEGUI__Rect_float__min(lua_State* tolua_S)
{
  CEGUI::Rect<float>* self = (CEGUI::Rect<float>*)  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::Vector2<float>",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_min = *((CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_max of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Rect_float__max
static int tolua_get_CEGUI__Rect_float__max(lua_State* tolua_S)
{
  CEGUI::Rect<float>* self = (CEGUI::Rect<float>*)  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::Vector2<float>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_max of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Rect_float__max
static int tolua_set_CEGUI__Rect_float__max(lua_State* tolua_S)
{
  CEGUI::Rect<float>* self = (CEGUI::Rect<float>*)  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::Vector2<float>",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_max = *((CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_new00
static int tolua_CEGUI_CEGUI_Rectf_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Rect<float>* tolua_ret = (CEGUI::Rect<float>*)  new CEGUI::Rect<float>();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Rect<float>");
 }
 }
 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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_new00_local
static int tolua_CEGUI_CEGUI_Rectf_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::Rect<float>* tolua_ret = (CEGUI::Rect<float>*)  new CEGUI::Rect<float>();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Rect<float>");
 }
 }
 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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_new01
static int tolua_CEGUI_CEGUI_Rectf_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect<float>",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
 {
  const float left = ((const float)  tolua_tonumber(tolua_S,2,0));
  const float top = ((const float)  tolua_tonumber(tolua_S,3,0));
  const float right = ((const float)  tolua_tonumber(tolua_S,4,0));
  const float bottom = ((const float)  tolua_tonumber(tolua_S,5,0));
 {
  CEGUI::Rect<float>* tolua_ret = (CEGUI::Rect<float>*)  new CEGUI::Rect<float>(left,top,right,bottom);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Rect<float>");
 tolua_pushnumber(tolua_S,(lua_Number)left);
 tolua_pushnumber(tolua_S,(lua_Number)top);
 tolua_pushnumber(tolua_S,(lua_Number)right);
 tolua_pushnumber(tolua_S,(lua_Number)bottom);
 }
 }
 return 5;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Rectf_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_new01_local
static int tolua_CEGUI_CEGUI_Rectf_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect<float>",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
 {
  const float left = ((const float)  tolua_tonumber(tolua_S,2,0));
  const float top = ((const float)  tolua_tonumber(tolua_S,3,0));
  const float right = ((const float)  tolua_tonumber(tolua_S,4,0));
  const float bottom = ((const float)  tolua_tonumber(tolua_S,5,0));
 {
  CEGUI::Rect<float>* tolua_ret = (CEGUI::Rect<float>*)  new CEGUI::Rect<float>(left,top,right,bottom);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Rect<float>");
 tolua_pushnumber(tolua_S,(lua_Number)left);
 tolua_pushnumber(tolua_S,(lua_Number)top);
 tolua_pushnumber(tolua_S,(lua_Number)right);
 tolua_pushnumber(tolua_S,(lua_Number)bottom);
 }
 }
 return 5;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Rectf_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_new02
static int tolua_CEGUI_CEGUI_Rectf_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Vector2<float>* min = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Vector2<float>* max = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Rect<float>* tolua_ret = (CEGUI::Rect<float>*)  new CEGUI::Rect<float>(*min,*max);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Rect<float>");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Rectf_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_new02_local
static int tolua_CEGUI_CEGUI_Rectf_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Vector2<float>* min = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Vector2<float>* max = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Rect<float>* tolua_ret = (CEGUI::Rect<float>*)  new CEGUI::Rect<float>(*min,*max);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Rect<float>");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Rectf_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_new03
static int tolua_CEGUI_CEGUI_Rectf_new03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Vector2<float>* pos = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Size<float>* size = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Rect<float>* tolua_ret = (CEGUI::Rect<float>*)  new CEGUI::Rect<float>(*pos,*size);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Rect<float>");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Rectf_new02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_new03_local
static int tolua_CEGUI_CEGUI_Rectf_new03_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Vector2<float>* pos = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Size<float>* size = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Rect<float>* tolua_ret = (CEGUI::Rect<float>*)  new CEGUI::Rect<float>(*pos,*size);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Rect<float>");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Rectf_new02_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_new04
static int tolua_CEGUI_CEGUI_Rectf_new04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Rect<float>* r = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::Rect<float>* tolua_ret = (CEGUI::Rect<float>*)  new CEGUI::Rect<float>(*r);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Rect<float>");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Rectf_new03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_new04_local
static int tolua_CEGUI_CEGUI_Rectf_new04_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Rect<float>* r = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::Rect<float>* tolua_ret = (CEGUI::Rect<float>*)  new CEGUI::Rect<float>(*r);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Rect<float>");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Rectf_new03_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: left of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_left00
static int tolua_CEGUI_CEGUI_Rectf_left00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect<float>",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<float>* self = (CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const float v = ((const float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'left'",NULL);
#endif
 {
  self->left(v);
 tolua_pushnumber(tolua_S,(lua_Number)v);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'left'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: top of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_top00
static int tolua_CEGUI_CEGUI_Rectf_top00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect<float>",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<float>* self = (CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const float v = ((const float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'top'",NULL);
#endif
 {
  self->top(v);
 tolua_pushnumber(tolua_S,(lua_Number)v);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'top'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: right of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_right00
static int tolua_CEGUI_CEGUI_Rectf_right00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect<float>",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<float>* self = (CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const float v = ((const float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'right'",NULL);
#endif
 {
  self->right(v);
 tolua_pushnumber(tolua_S,(lua_Number)v);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'right'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: bottom of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_bottom00
static int tolua_CEGUI_CEGUI_Rectf_bottom00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect<float>",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<float>* self = (CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const float v = ((const float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'bottom'",NULL);
#endif
 {
  self->bottom(v);
 tolua_pushnumber(tolua_S,(lua_Number)v);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'bottom'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

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

/* method: setPosition of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_setPosition00
static int tolua_CEGUI_CEGUI_Rectf_setPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect<float>* self = (CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2<float>* min = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPosition'",NULL);
#endif
 {
  self->setPosition(*min);
 }
 }
 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::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_getPosition00
static int tolua_CEGUI_CEGUI_Rectf_getPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect<float>* self = (const CEGUI::Rect<float>*)  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<float>& tolua_ret = (const CEGUI::Vector2<float>&)  self->getPosition();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector2<float>");
 }
 }
 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: setSize of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_setSize00
static int tolua_CEGUI_CEGUI_Rectf_setSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect<float>* self = (CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size<float>* size = ((const CEGUI::Size<float>*)  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: getSize of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_getSize00
static int tolua_CEGUI_CEGUI_Rectf_getSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect<float>* self = (const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSize'",NULL);
#endif
 {
  CEGUI::Size<float> tolua_ret = (CEGUI::Size<float>)  self->getSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#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: setWidth of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_setWidth00
static int tolua_CEGUI_CEGUI_Rectf_setWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect<float>",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<float>* self = (CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const float w = ((const 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);
 tolua_pushnumber(tolua_S,(lua_Number)w);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getWidth of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_getWidth00
static int tolua_CEGUI_CEGUI_Rectf_getWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect<float>* self = (const CEGUI::Rect<float>*)  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: setHeight of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_setHeight00
static int tolua_CEGUI_CEGUI_Rectf_setHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect<float>",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<float>* self = (CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const float h = ((const 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);
 tolua_pushnumber(tolua_S,(lua_Number)h);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHeight of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_getHeight00
static int tolua_CEGUI_CEGUI_Rectf_getHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect<float>* self = (const CEGUI::Rect<float>*)  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: getIntersection of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_getIntersection00
static int tolua_CEGUI_CEGUI_Rectf_getIntersection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect<float>* self = (const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Rect<float>* rect = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getIntersection'",NULL);
#endif
 {
  CEGUI::Rect<float> tolua_ret = (CEGUI::Rect<float>)  self->getIntersection(*rect);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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: offset of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_offset00
static int tolua_CEGUI_CEGUI_Rectf_offset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect<float>* self = (CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2<float>* v = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'offset'",NULL);
#endif
 {
  self->offset(*v);
 }
 }
 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: isPointInRect of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_isPointInRect00
static int tolua_CEGUI_CEGUI_Rectf_isPointInRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect<float>* self = (const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2<float>* v = ((const CEGUI::Vector2<float>*)  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(*v);
 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: constrainSizeMax of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_constrainSizeMax00
static int tolua_CEGUI_CEGUI_Rectf_constrainSizeMax00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect<float>* self = (CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size<float>* size = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'constrainSizeMax'",NULL);
#endif
 {
  self->constrainSizeMax(*size);
 }
 }
 return 0;
#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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_constrainSizeMin00
static int tolua_CEGUI_CEGUI_Rectf_constrainSizeMin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect<float>* self = (CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size<float>* size = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'constrainSizeMin'",NULL);
#endif
 {
  self->constrainSizeMin(*size);
 }
 }
 return 0;
#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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf_constrainSize00
static int tolua_CEGUI_CEGUI_Rectf_constrainSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Rect<float>* self = (CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size<float>* max_sz = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Size<float>* min_sz = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'constrainSize'",NULL);
#endif
 {
  self->constrainSize(*max_sz,*min_sz);
 }
 }
 return 0;
#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<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf__eq00
static int tolua_CEGUI_CEGUI_Rectf__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect<float>* self = (const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Rect<float>* rhs = ((const CEGUI::Rect<float>*)  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: operator* of class  CEGUI::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf__mul00
static int tolua_CEGUI_CEGUI_Rectf__mul00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect<float>",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::Rect<float>* self = (const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  float scalar = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
#endif
 {
  CEGUI::Rect<float> tolua_ret = (CEGUI::Rect<float>)  self->operator*(scalar);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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::Rect<float> */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rectf__add00
static int tolua_CEGUI_CEGUI_Rectf__add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect<float>* self = (const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Rect<float>* r = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'",NULL);
#endif
 {
  CEGUI::Rect<float> tolua_ret = (CEGUI::Rect<float>)  self->operator+(*r);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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

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

/* set function: d_w of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Quaternion_w
static int tolua_set_CEGUI__Quaternion_w(lua_State* tolua_S)
{
  CEGUI::Quaternion* self = (CEGUI::Quaternion*)  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_w'",NULL);
 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_w = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_x of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Quaternion_x
static int tolua_get_CEGUI__Quaternion_x(lua_State* tolua_S)
{
  CEGUI::Quaternion* self = (CEGUI::Quaternion*)  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::Quaternion */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Quaternion_x
static int tolua_set_CEGUI__Quaternion_x(lua_State* tolua_S)
{
  CEGUI::Quaternion* self = (CEGUI::Quaternion*)  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::Quaternion */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Quaternion_y
static int tolua_get_CEGUI__Quaternion_y(lua_State* tolua_S)
{
  CEGUI::Quaternion* self = (CEGUI::Quaternion*)  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::Quaternion */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Quaternion_y
static int tolua_set_CEGUI__Quaternion_y(lua_State* tolua_S)
{
  CEGUI::Quaternion* self = (CEGUI::Quaternion*)  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::Quaternion */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Quaternion_z
static int tolua_get_CEGUI__Quaternion_z(lua_State* tolua_S)
{
  CEGUI::Quaternion* self = (CEGUI::Quaternion*)  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::Quaternion */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__Quaternion_z
static int tolua_set_CEGUI__Quaternion_z(lua_State* tolua_S)
{
  CEGUI::Quaternion* self = (CEGUI::Quaternion*)  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

/* get function: ZERO of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Quaternion_ZERO
static int tolua_get_CEGUI__Quaternion_ZERO(lua_State* tolua_S)
{
 tolua_pushusertype(tolua_S,(void*)&CEGUI::Quaternion::ZERO,"const CEGUI::Quaternion");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: IDENTITY of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__Quaternion_IDENTITY
static int tolua_get_CEGUI__Quaternion_IDENTITY(lua_State* tolua_S)
{
 tolua_pushusertype(tolua_S,(void*)&CEGUI::Quaternion::IDENTITY,"const CEGUI::Quaternion");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: eulerAnglesRadians of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion_eulerAnglesRadians00
static int tolua_CEGUI_CEGUI_Quaternion_eulerAnglesRadians00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Quaternion",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
 {
  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::Quaternion tolua_ret = (CEGUI::Quaternion)  CEGUI::Quaternion::eulerAnglesRadians(x,y,z);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Quaternion(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Quaternion));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'eulerAnglesRadians'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: eulerAnglesDegrees of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion_eulerAnglesDegrees00
static int tolua_CEGUI_CEGUI_Quaternion_eulerAnglesDegrees00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Quaternion",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
 {
  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::Quaternion tolua_ret = (CEGUI::Quaternion)  CEGUI::Quaternion::eulerAnglesDegrees(x,y,z);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Quaternion(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Quaternion));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'eulerAnglesDegrees'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: axisAngleRadians of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion_axisAngleRadians00
static int tolua_CEGUI_CEGUI_Quaternion_axisAngleRadians00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector3<float>",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::Vector3<float>* axis = ((const CEGUI::Vector3<float>*)  tolua_tousertype(tolua_S,2,0));
  float rotation = ((float)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::Quaternion tolua_ret = (CEGUI::Quaternion)  CEGUI::Quaternion::axisAngleRadians(*axis,rotation);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Quaternion(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Quaternion));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'axisAngleRadians'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: axisAngleDegrees of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion_axisAngleDegrees00
static int tolua_CEGUI_CEGUI_Quaternion_axisAngleDegrees00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector3<float>",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::Vector3<float>* axis = ((const CEGUI::Vector3<float>*)  tolua_tousertype(tolua_S,2,0));
  float rotation = ((float)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::Quaternion tolua_ret = (CEGUI::Quaternion)  CEGUI::Quaternion::axisAngleDegrees(*axis,rotation);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Quaternion(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Quaternion));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'axisAngleDegrees'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: slerp of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion_slerp00
static int tolua_CEGUI_CEGUI_Quaternion_slerp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
 !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Quaternion* left = ((const CEGUI::Quaternion*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Quaternion* right = ((const CEGUI::Quaternion*)  tolua_tousertype(tolua_S,3,0));
  float position = ((float)  tolua_tonumber(tolua_S,4,0));
  bool shortestPath = ((bool)  tolua_toboolean(tolua_S,5,false));
 {
  CEGUI::Quaternion tolua_ret = (CEGUI::Quaternion)  CEGUI::Quaternion::slerp(*left,*right,position,shortestPath);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Quaternion(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Quaternion));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'slerp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion_new00
static int tolua_CEGUI_CEGUI_Quaternion_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  float w = ((float)  tolua_tonumber(tolua_S,2,1.0));
  float x = ((float)  tolua_tonumber(tolua_S,3,0.0));
  float y = ((float)  tolua_tonumber(tolua_S,4,0.0));
  float z = ((float)  tolua_tonumber(tolua_S,5,0.0));
 {
  CEGUI::Quaternion* tolua_ret = (CEGUI::Quaternion*)  new CEGUI::Quaternion(w,x,y,z);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Quaternion");
 }
 }
 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::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion_new00_local
static int tolua_CEGUI_CEGUI_Quaternion_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  float w = ((float)  tolua_tonumber(tolua_S,2,1.0));
  float x = ((float)  tolua_tonumber(tolua_S,3,0.0));
  float y = ((float)  tolua_tonumber(tolua_S,4,0.0));
  float z = ((float)  tolua_tonumber(tolua_S,5,0.0));
 {
  CEGUI::Quaternion* tolua_ret = (CEGUI::Quaternion*)  new CEGUI::Quaternion(w,x,y,z);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::Quaternion");
 }
 }
 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::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion_new01
static int tolua_CEGUI_CEGUI_Quaternion_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Quaternion* v = ((const CEGUI::Quaternion*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::Quaternion* tolua_ret = (CEGUI::Quaternion*)  new CEGUI::Quaternion(*v);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Quaternion");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Quaternion_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: operator== of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion__eq00
static int tolua_CEGUI_CEGUI_Quaternion__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Quaternion* self = (const CEGUI::Quaternion*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Quaternion* v = ((const CEGUI::Quaternion*)  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==(*v);
 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: operator- of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion__sub00
static int tolua_CEGUI_CEGUI_Quaternion__sub00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Quaternion* self = (const CEGUI::Quaternion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'",NULL);
#endif
 {
  CEGUI::Quaternion tolua_ret = (CEGUI::Quaternion)  self->operator-();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Quaternion(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Quaternion));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#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::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion__add00
static int tolua_CEGUI_CEGUI_Quaternion__add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Quaternion* self = (const CEGUI::Quaternion*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Quaternion* v = ((const CEGUI::Quaternion*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'",NULL);
#endif
 {
  CEGUI::Quaternion tolua_ret = (CEGUI::Quaternion)  self->operator+(*v);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Quaternion(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Quaternion));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#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::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion__mul00
static int tolua_CEGUI_CEGUI_Quaternion__mul00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Quaternion* self = (const CEGUI::Quaternion*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Quaternion* v = ((const CEGUI::Quaternion*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
#endif
 {
  CEGUI::Quaternion tolua_ret = (CEGUI::Quaternion)  self->operator*(*v);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Quaternion(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Quaternion));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#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::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion__mul01
static int tolua_CEGUI_CEGUI_Quaternion__mul01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Quaternion* self = (const CEGUI::Quaternion*)  tolua_tousertype(tolua_S,1,0);
  float v = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
#endif
 {
  CEGUI::Quaternion tolua_ret = (CEGUI::Quaternion)  self->operator*(v);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Quaternion(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Quaternion));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Quaternion");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Quaternion__mul00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: length of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion_length00
static int tolua_CEGUI_CEGUI_Quaternion_length00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Quaternion* self = (const CEGUI::Quaternion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'length'",NULL);
#endif
 {
  float tolua_ret = (float)  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: normalise of class  CEGUI::Quaternion */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Quaternion_normalise00
static int tolua_CEGUI_CEGUI_Quaternion_normalise00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Quaternion",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Quaternion* self = (CEGUI::Quaternion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'normalise'",NULL);
#endif
 {
  float tolua_ret = (float)  self->normalise();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'normalise'.",&tolua_err);
 return 0;
#endif
}
#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: 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: 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_width of class  CEGUI::USize */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__USize_width
static int tolua_get_CEGUI__USize_width(lua_State* tolua_S)
{
  CEGUI::USize* self = (CEGUI::USize*)  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_pushusertype(tolua_S,(void*)&self->d_width,"CEGUI::UDim");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_width of class  CEGUI::USize */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__USize_width
static int tolua_set_CEGUI__USize_width(lua_State* tolua_S)
{
  CEGUI::USize* self = (CEGUI::USize*)  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_isusertype(tolua_S,2,"CEGUI::UDim",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_width = *((CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: d_height of class  CEGUI::USize */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__USize_height
static int tolua_get_CEGUI__USize_height(lua_State* tolua_S)
{
  CEGUI::USize* self = (CEGUI::USize*)  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_pushusertype(tolua_S,(void*)&self->d_height,"CEGUI::UDim");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: d_height of class  CEGUI::USize */
#ifndef TOLUA_DISABLE_tolua_set_CEGUI__USize_height
static int tolua_set_CEGUI__USize_height(lua_State* tolua_S)
{
  CEGUI::USize* self = (CEGUI::USize*)  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_isusertype(tolua_S,2,"CEGUI::UDim",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->d_height = *((CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  CEGUI::USize */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_USize__eq00
static int tolua_CEGUI_CEGUI_USize__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::USize",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::USize",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::USize* self = (const CEGUI::USize*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::USize* sz = ((const CEGUI::USize*)  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::USize */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_USize_new00
static int tolua_CEGUI_CEGUI_USize_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::USize",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::USize* tolua_ret = (CEGUI::USize*)  new CEGUI::USize();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::USize");
 }
 }
 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::USize */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_USize_new00_local
static int tolua_CEGUI_CEGUI_USize_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::USize",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::USize* tolua_ret = (CEGUI::USize*)  new CEGUI::USize();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::USize");
 }
 }
 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::USize */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_USize_new01
static int tolua_CEGUI_CEGUI_USize_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::USize",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_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UDim* w = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UDim* h = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::USize* tolua_ret = (CEGUI::USize*)  new CEGUI::USize(*w,*h);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::USize");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_USize_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::USize */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_USize_new01_local
static int tolua_CEGUI_CEGUI_USize_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::USize",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_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UDim* w = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::UDim* h = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::USize* tolua_ret = (CEGUI::USize*)  new CEGUI::USize(*w,*h);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::USize");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_USize_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: 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::USize tolua_ret = (CEGUI::USize)  self->getSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::USize(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::USize");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::USize));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::USize");
#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::USize",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::USize* sz = ((const CEGUI::USize*)  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: 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<float>",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<float>* sz = ((const CEGUI::Size<float>*)  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: 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<float>",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<float>* sz = ((const CEGUI::Size<float>*)  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: setAutoScaled of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_setAutoScaled00
static int tolua_CEGUI_CEGUI_Font_setAutoScaled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"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
 {
  CEGUI::Font* self = (CEGUI::Font*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::AutoScaledMode auto_scaled = ((CEGUI::AutoScaledMode) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoScaled'",NULL);
#endif
 {
  self->setAutoScaled(auto_scaled);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoScaled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAutoScaled of class  CEGUI::Font */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Font_getAutoScaled00
static int tolua_CEGUI_CEGUI_Font_getAutoScaled00(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 'getAutoScaled'",NULL);
#endif
 {
  CEGUI::AutoScaledMode tolua_ret = (CEGUI::AutoScaledMode)  self->getAutoScaled();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAutoScaled'.",&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: createFromFile of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_createFromFile00
static int tolua_CEGUI_CEGUI_FontManager_createFromFile00(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_isnumber(tolua_S,4,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&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 resource_group = ((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 'createFromFile'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::Font& tolua_ret = (CEGUI::Font&)  self->createFromFile(xml_filename,resource_group,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 'createFromFile'\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 'createFromFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createFromString of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_createFromString00
static int tolua_CEGUI_CEGUI_FontManager_createFromString00(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,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 source = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::XMLResourceExistsAction action = ((CEGUI::XMLResourceExistsAction) (int)  tolua_tonumber(tolua_S,3,CEGUI::XREA_RETURN));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createFromString'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::Font& tolua_ret = (CEGUI::Font&)  self->createFromString(source,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 'createFromString'\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 'createFromString'.",&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_isutf8string(tolua_S,5,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,6,1,&tolua_err) ||
 !tolua_isnumber(tolua_S,7,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontManager* self = (CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
  const utf8string font_name = ((const utf8string)  tolua_toutf8string(tolua_S,2,0));
  const float point_size = ((const float)  tolua_tonumber(tolua_S,3,0));
  const bool anti_aliased = ((const bool)  tolua_toboolean(tolua_S,4,0));
  const utf8string font_filename = ((const utf8string)  tolua_toutf8string(tolua_S,5,0));
  const utf8string resource_group = ((const utf8string)  tolua_toutf8string(tolua_S,6,""));
  CEGUI::AutoScaledMode auto_scaled = ((CEGUI::AutoScaledMode) (int)  tolua_tonumber(tolua_S,7,CEGUI::ASM_Disabled));
#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);
 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: createFreeTypeFont of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_createFreeTypeFont01
static int tolua_CEGUI_CEGUI_FontManager_createFreeTypeFont01(lua_State* tolua_S)
{
 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_isutf8string(tolua_S,5,0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,6,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,8,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,9,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,10,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::FontManager* self = (CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
  const utf8string font_name = ((const utf8string)  tolua_toutf8string(tolua_S,2,0));
  const float point_size = ((const float)  tolua_tonumber(tolua_S,3,0));
  const bool anti_aliased = ((const bool)  tolua_toboolean(tolua_S,4,0));
  const utf8string font_filename = ((const utf8string)  tolua_toutf8string(tolua_S,5,0));
  const utf8string resource_group = ((const utf8string)  tolua_toutf8string(tolua_S,6,0));
  CEGUI::AutoScaledMode auto_scaled = ((CEGUI::AutoScaledMode) (int)  tolua_tonumber(tolua_S,7,0));
  const CEGUI::Size<float>* native_res = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,8,0));
  CEGUI::XMLResourceExistsAction action = ((CEGUI::XMLResourceExistsAction) (int)  tolua_tonumber(tolua_S,9,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_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;
tolua_lerror:
 return tolua_CEGUI_CEGUI_FontManager_createFreeTypeFont00(tolua_S);
}
#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_isnumber(tolua_S,5,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontManager* self = (CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
  const utf8string font_name = ((const utf8string)  tolua_toutf8string(tolua_S,2,0));
  const utf8string imageset_filename = ((const utf8string)  tolua_toutf8string(tolua_S,3,0));
  const utf8string resource_group = ((const utf8string)  tolua_toutf8string(tolua_S,4,""));
  CEGUI::AutoScaledMode auto_scaled = ((CEGUI::AutoScaledMode) (int)  tolua_tonumber(tolua_S,5,CEGUI::ASM_Disabled));
#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);
 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: createPixmapFont of class  CEGUI::FontManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontManager_createPixmapFont01
static int tolua_CEGUI_CEGUI_FontManager_createPixmapFont01(lua_State* tolua_S)
{
 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,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,6,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,7,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::FontManager* self = (CEGUI::FontManager*)  tolua_tousertype(tolua_S,1,0);
  const utf8string font_name = ((const utf8string)  tolua_toutf8string(tolua_S,2,0));
  const utf8string imageset_filename = ((const utf8string)  tolua_toutf8string(tolua_S,3,0));
  const utf8string resource_group = ((const utf8string)  tolua_toutf8string(tolua_S,4,0));
  CEGUI::AutoScaledMode auto_scaled = ((CEGUI::AutoScaledMode) (int)  tolua_tonumber(tolua_S,5,0));
  const CEGUI::Size<float>* native_res = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,6,0));
  CEGUI::XMLResourceExistsAction action = ((CEGUI::XMLResourceExistsAction) (int)  tolua_tonumber(tolua_S,7,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_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;
tolua_lerror:
 return tolua_CEGUI_CEGUI_FontManager_createPixmapFont00(tolua_S);
}
#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<float>",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<float>* sz = ((const CEGUI::Size<float>*)  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: 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
 {
  const string tolua_ret = (const 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: getRenderedSize of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_getRenderedSize00
static int tolua_CEGUI_CEGUI_Image_getRenderedSize00(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 'getRenderedSize'",NULL);
#endif
 {
  const CEGUI::Size<float>& tolua_ret = (const CEGUI::Size<float>&)  self->getRenderedSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size<float>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRenderedSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRenderedOffset of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_getRenderedOffset00
static int tolua_CEGUI_CEGUI_Image_getRenderedOffset00(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 'getRenderedOffset'",NULL);
#endif
 {
  const CEGUI::Vector2<float>& tolua_ret = (const CEGUI::Vector2<float>&)  self->getRenderedOffset();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector2<float>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRenderedOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_render00
static int tolua_CEGUI_CEGUI_Image_render00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::GeometryBuffer* buffer = ((CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Rect<float>* dest_area = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Rect<float>* clip_area = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::ColourRect* colours = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*buffer,*dest_area,clip_area,*colours);
 }
 }
 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::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_render01
static int tolua_CEGUI_CEGUI_Image_render01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::Rect<float>",1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::GeometryBuffer* buffer = ((CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Vector2<float>* position = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Rect<float>* clip_area = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*buffer,*position,clip_area);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Image_render00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_render02
static int tolua_CEGUI_CEGUI_Image_render02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::GeometryBuffer* buffer = ((CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Vector2<float>* position = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Rect<float>* clip_area = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::ColourRect* colours = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*buffer,*position,clip_area,*colours);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Image_render01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_render03
static int tolua_CEGUI_CEGUI_Image_render03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::Rect<float>",1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::GeometryBuffer* buffer = ((CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Vector2<float>* position = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Size<float>* size = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Rect<float>* clip_area = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,5,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*buffer,*position,*size,clip_area);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Image_render02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: render of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_render04
static int tolua_CEGUI_CEGUI_Image_render04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Image",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,6,"const CEGUI::ColourRect",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::Image* self = (const CEGUI::Image*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::GeometryBuffer* buffer = ((CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Vector2<float>* position = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Size<float>* size = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Rect<float>* clip_area = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,5,0));
  const CEGUI::ColourRect* colours = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,6,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'render'",NULL);
#endif
 {
  self->render(*buffer,*position,*size,clip_area,*colours);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Image_render03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: computeScalingFactors of class  CEGUI::Image */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Image_computeScalingFactors00
static int tolua_CEGUI_CEGUI_Image_computeScalingFactors00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::Image",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
 !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AutoScaledMode mode = ((CEGUI::AutoScaledMode) (int)  tolua_tonumber(tolua_S,2,0));
  const CEGUI::Size<float>* display_size = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::Size<float>* native_display_size = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,4,0));
  float x_scale = ((float)  tolua_tonumber(tolua_S,5,0));
  float y_scale = ((float)  tolua_tonumber(tolua_S,6,0));
 {
  CEGUI::Image::computeScalingFactors(mode,*display_size,*native_display_size,x_scale,y_scale);
 tolua_pushnumber(tolua_S,(lua_Number)x_scale);
 tolua_pushnumber(tolua_S,(lua_Number)y_scale);
 }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'computeScalingFactors'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTexture of class  CEGUI::BasicImage */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_BasicImage_setTexture00
static int tolua_CEGUI_CEGUI_BasicImage_setTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::BasicImage",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::BasicImage* self = (CEGUI::BasicImage*)  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 'setTexture'",NULL);
#endif
 {
  self->setTexture(texture);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setArea of class  CEGUI::BasicImage */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_BasicImage_setArea00
static int tolua_CEGUI_CEGUI_BasicImage_setArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::BasicImage",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::BasicImage* self = (CEGUI::BasicImage*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Rect<float>* pixel_area = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setArea'",NULL);
#endif
 {
  self->setArea(*pixel_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: setOffset of class  CEGUI::BasicImage */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_BasicImage_setOffset00
static int tolua_CEGUI_CEGUI_BasicImage_setOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::BasicImage",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::BasicImage* self = (CEGUI::BasicImage*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Vector2<float>* pixel_offset = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOffset'",NULL);
#endif
 {
  self->setOffset(*pixel_offset);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setNativeResolution of class  CEGUI::BasicImage */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_BasicImage_setNativeResolution00
static int tolua_CEGUI_CEGUI_BasicImage_setNativeResolution00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::BasicImage",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::BasicImage* self = (CEGUI::BasicImage*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size<float>* native_res = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNativeResolution'",NULL);
#endif
 {
  self->setNativeResolution(*native_res);
 }
 }
 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: delete of class  CEGUI::ImagePair */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagePair_delete00
static int tolua_CEGUI_CEGUI_ImagePair_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagePair",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagePair* self = (CEGUI::ImagePair*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
 delete self;
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

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

/* method: getSingleton of class  CEGUI::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_getSingleton00
static int tolua_CEGUI_CEGUI_ImageManager_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImageManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::ImageManager& tolua_ret = (CEGUI::ImageManager&)  CEGUI::ImageManager::getSingleton();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::ImageManager");
 }
 }
 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: removeImageType of class  CEGUI::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_removeImageType00
static int tolua_CEGUI_CEGUI_ImageManager_removeImageType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageManager* self = (CEGUI::ImageManager*)  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 'removeImageType'",NULL);
#endif
 {
  self->removeImageType(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeImageType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isImageTypeAvailable of class  CEGUI::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_isImageTypeAvailable00
static int tolua_CEGUI_CEGUI_ImageManager_isImageTypeAvailable00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageManager",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::ImageManager* self = (const CEGUI::ImageManager*)  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 'isImageTypeAvailable'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isImageTypeAvailable(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isImageTypeAvailable'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: create of class  CEGUI::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_create00
static int tolua_CEGUI_CEGUI_ImageManager_create00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageManager",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::ImageManager* self = (CEGUI::ImageManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string type = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'create'",NULL);
#endif
 {
  CEGUI::Image& tolua_ret = (CEGUI::Image&)  self->create(type,name);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Image");
 }
 }
 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::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_destroy00
static int tolua_CEGUI_CEGUI_ImageManager_destroy00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Image",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageManager* self = (CEGUI::ImageManager*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Image* image = ((CEGUI::Image*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroy'",NULL);
#endif
 {
  self->destroy(*image);
 }
 }
 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::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_destroy01
static int tolua_CEGUI_CEGUI_ImageManager_destroy01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageManager",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ImageManager* self = (CEGUI::ImageManager*)  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_ImageManager_destroy00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyAll of class  CEGUI::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_destroyAll00
static int tolua_CEGUI_CEGUI_ImageManager_destroyAll00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageManager* self = (CEGUI::ImageManager*)  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::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_get00
static int tolua_CEGUI_CEGUI_ImageManager_get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageManager",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::ImageManager* self = (const CEGUI::ImageManager*)  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::Image& tolua_ret = (CEGUI::Image&)  self->get(name);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Image");
 }
 }
 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::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_isDefined00
static int tolua_CEGUI_CEGUI_ImageManager_isDefined00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageManager",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::ImageManager* self = (const CEGUI::ImageManager*)  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: getImageCount of class  CEGUI::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_getImageCount00
static int tolua_CEGUI_CEGUI_ImageManager_getImageCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageManager* self = (const CEGUI::ImageManager*)  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: loadImageset of class  CEGUI::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_loadImageset00
static int tolua_CEGUI_CEGUI_ImageManager_loadImageset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageManager",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::ImageManager* self = (CEGUI::ImageManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string filename = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string resource_group = ((utf8string)  tolua_toutf8string(tolua_S,3,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadImageset'",NULL);
#endif
 {
  self->loadImageset(filename,resource_group);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadImageset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyImageCollection of class  CEGUI::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_destroyImageCollection00
static int tolua_CEGUI_CEGUI_ImageManager_destroyImageCollection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageManager",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
 {
  CEGUI::ImageManager* self = (CEGUI::ImageManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string prefix = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  bool delete_texture = ((bool)  tolua_toboolean(tolua_S,3,true));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyImageCollection'",NULL);
#endif
 {
  self->destroyImageCollection(prefix,delete_texture);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyImageCollection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addFromImageFile of class  CEGUI::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_addFromImageFile00
static int tolua_CEGUI_CEGUI_ImageManager_addFromImageFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageManager",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::ImageManager* self = (CEGUI::ImageManager*)  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 resource_group = ((utf8string)  tolua_toutf8string(tolua_S,4,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addFromImageFile'",NULL);
#endif
 {
  self->addFromImageFile(name,filename,resource_group);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addFromImageFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: notifyDisplaySizeChanged of class  CEGUI::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_notifyDisplaySizeChanged00
static int tolua_CEGUI_CEGUI_ImageManager_notifyDisplaySizeChanged00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageManager* self = (CEGUI::ImageManager*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size<float>* size = ((const CEGUI::Size<float>*)  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: setImagesetDefaultResourceGroup of class  CEGUI::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_setImagesetDefaultResourceGroup00
static int tolua_CEGUI_CEGUI_ImageManager_setImagesetDefaultResourceGroup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImageManager",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::ImageManager::setImagesetDefaultResourceGroup(resourceGroup);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setImagesetDefaultResourceGroup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getIterator of class  CEGUI::ImageManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageManager_getIterator00
static int tolua_CEGUI_CEGUI_ImageManager_getIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageManager* self = (const CEGUI::ImageManager*)  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: 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: 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::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

/* 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::ImagePair tolua_ret = (CEGUI::ImagePair)  self->getCurrentValue();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::ImagePair(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ImagePair");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::ImagePair));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::ImagePair");
#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: new of class  CEGUI::SimpleTimer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SimpleTimer_new00
static int tolua_CEGUI_CEGUI_SimpleTimer_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::SimpleTimer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::SimpleTimer* tolua_ret = (CEGUI::SimpleTimer*)  new CEGUI::SimpleTimer();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::SimpleTimer");
 }
 }
 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::SimpleTimer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SimpleTimer_new00_local
static int tolua_CEGUI_CEGUI_SimpleTimer_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::SimpleTimer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::SimpleTimer* tolua_ret = (CEGUI::SimpleTimer*)  new CEGUI::SimpleTimer();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::SimpleTimer");
 }
 }
 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: currentTime of class  CEGUI::SimpleTimer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SimpleTimer_currentTime00
static int tolua_CEGUI_CEGUI_SimpleTimer_currentTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::SimpleTimer",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  double tolua_ret = (double)  CEGUI::SimpleTimer::currentTime();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'currentTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: reset of class  CEGUI::SystemKeys */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SystemKeys_reset00
static int tolua_CEGUI_CEGUI_SystemKeys_reset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::SystemKeys",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SystemKeys* self = (CEGUI::SystemKeys*)  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: get of class  CEGUI::SystemKeys */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SystemKeys_get00
static int tolua_CEGUI_CEGUI_SystemKeys_get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SystemKeys",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::SystemKeys* self = (const CEGUI::SystemKeys*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->get();
 tolua_pushnumber(tolua_S,(lua_Number)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: isPressed of class  CEGUI::SystemKeys */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SystemKeys_isPressed00
static int tolua_CEGUI_CEGUI_SystemKeys_isPressed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::SystemKeys",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::SystemKeys* self = (const CEGUI::SystemKeys*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::SystemKeys::SystemKey key = ((CEGUI::SystemKeys::SystemKey) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isPressed'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isPressed(key);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isPressed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

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

/* method: mouseButtonToSystemKey of class  CEGUI::SystemKeys */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SystemKeys_mouseButtonToSystemKey00
static int tolua_CEGUI_CEGUI_SystemKeys_mouseButtonToSystemKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::SystemKeys",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::MouseButton button = ((CEGUI::MouseButton) (int)  tolua_tonumber(tolua_S,2,0));
 {
  CEGUI::SystemKeys::SystemKey tolua_ret = (CEGUI::SystemKeys::SystemKey)  CEGUI::SystemKeys::mouseButtonToSystemKey(button);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'mouseButtonToSystemKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: keyCodeToSystemKey of class  CEGUI::SystemKeys */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SystemKeys_keyCodeToSystemKey00
static int tolua_CEGUI_CEGUI_SystemKeys_keyCodeToSystemKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::SystemKeys",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Key::Scan key = ((CEGUI::Key::Scan) (int)  tolua_tonumber(tolua_S,2,0));
 {
  CEGUI::SystemKeys::SystemKey tolua_ret = (CEGUI::SystemKeys::SystemKey)  CEGUI::SystemKeys::keyCodeToSystemKey(key);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'keyCodeToSystemKey'.",&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<float>");
 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<float>",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->position = *((CEGUI::Vector2<float>*)  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<float>");
 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<float>",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->moveDelta = *((CEGUI::Vector2<float>*)  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: 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_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::MouseCursor* self = (CEGUI::MouseCursor*)  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 'setImage'",NULL);
#endif
 {
  self->setImage(name);
 }
 }
 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: setDefaultImage of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_setDefaultImage00
static int tolua_CEGUI_CEGUI_MouseCursor_setDefaultImage00(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 'setDefaultImage'",NULL);
#endif
 {
  self->setDefaultImage(image);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDefaultImage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDefaultImage of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_setDefaultImage01
static int tolua_CEGUI_CEGUI_MouseCursor_setDefaultImage01(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_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::MouseCursor* self = (CEGUI::MouseCursor*)  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 'setDefaultImage'",NULL);
#endif
 {
  self->setDefaultImage(name);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_MouseCursor_setDefaultImage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultImage of class  CEGUI::MouseCursor */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MouseCursor_getDefaultImage00
static int tolua_CEGUI_CEGUI_MouseCursor_getDefaultImage00(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 'getDefaultImage'",NULL);
#endif
 {
  const CEGUI::Image* tolua_ret = (const CEGUI::Image*)  self->getDefaultImage();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Image");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultImage'.",&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<float>",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<float>* pos = ((const CEGUI::Vector2<float>*)  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<float>",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<float>* offset = ((const CEGUI::Vector2<float>*)  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<float>",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<float>* area = ((const CEGUI::Rect<float>*)  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<float> tolua_ret = (CEGUI::Vector2<float>)  self->getPosition();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#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<float> tolua_ret = (CEGUI::Rect<float>)  self->getConstraintArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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<float> tolua_ret = (CEGUI::Vector2<float>)  self->getDisplayIndependantPosition();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#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<float>",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<float>* size = ((const CEGUI::Size<float>*)  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<float>& tolua_ret = (const CEGUI::Size<float>&)  self->getExplicitRenderSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size<float>");
 }
 }
 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: new of class  CEGUI::ElementEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ElementEventArgs_new00
static int tolua_CEGUI_CEGUI_ElementEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ElementEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* element = ((CEGUI::Element*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::ElementEventArgs* tolua_ret = (CEGUI::ElementEventArgs*)  new CEGUI::ElementEventArgs(element);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ElementEventArgs");
 }
 }
 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::ElementEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ElementEventArgs_new00_local
static int tolua_CEGUI_CEGUI_ElementEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ElementEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* element = ((CEGUI::Element*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::ElementEventArgs* tolua_ret = (CEGUI::ElementEventArgs*)  new CEGUI::ElementEventArgs(element);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::ElementEventArgs");
 }
 }
 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: element of class  CEGUI::ElementEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__ElementEventArgs_element_ptr
static int tolua_get_CEGUI__ElementEventArgs_element_ptr(lua_State* tolua_S)
{
  CEGUI::ElementEventArgs* self = (CEGUI::ElementEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'element'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)self->element,"CEGUI::Element");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: get of class  CachedRectf */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_CachedRectf_get00
static int tolua_CEGUI_CEGUI_Element_CachedRectf_get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element::CachedRectf",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element::CachedRectf* self = (const CEGUI::Element::CachedRectf*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'",NULL);
#endif
 {
  const CEGUI::Rect<float>& tolua_ret = (const CEGUI::Rect<float>&)  self->get();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Rect<float>");
 }
 }
 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: getFresh of class  CachedRectf */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_CachedRectf_getFresh00
static int tolua_CEGUI_CEGUI_Element_CachedRectf_getFresh00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element::CachedRectf",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::Element::CachedRectf* self = (const CEGUI::Element::CachedRectf*)  tolua_tousertype(tolua_S,1,0);
  bool skipAllPixelAlignment = ((bool)  tolua_toboolean(tolua_S,2,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFresh'",NULL);
#endif
 {
  CEGUI::Rect<float> tolua_ret = (CEGUI::Rect<float>)  self->getFresh(skipAllPixelAlignment);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getFresh'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

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

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

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

/* method: setArea of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setArea00
static int tolua_CEGUI_CEGUI_Element_setArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",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::Element* self = (CEGUI::Element*)  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;
#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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setArea01
static int tolua_CEGUI_CEGUI_Element_setArea01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::USize",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Element* self = (CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UVector2* pos = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::USize* size = ((const CEGUI::USize*)  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_Element_setArea00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setArea of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setArea02
static int tolua_CEGUI_CEGUI_Element_setArea02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",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
 {
  CEGUI::Element* self = (CEGUI::Element*)  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;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Element_setArea01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getArea of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getArea00
static int tolua_CEGUI_CEGUI_Element_getArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  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: setPosition of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setPosition00
static int tolua_CEGUI_CEGUI_Element_setPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",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::Element* self = (CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setXPosition00
static int tolua_CEGUI_CEGUI_Element_setXPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",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::Element* self = (CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* pos = ((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(*pos);
 }
 }
 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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setYPosition00
static int tolua_CEGUI_CEGUI_Element_setYPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",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::Element* self = (CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* pos = ((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(*pos);
 }
 }
 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: getPosition of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getPosition00
static int tolua_CEGUI_CEGUI_Element_getPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getXPosition00
static int tolua_CEGUI_CEGUI_Element_getXPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getYPosition00
static int tolua_CEGUI_CEGUI_Element_getYPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  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: setHorizontalAlignment of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setHorizontalAlignment00
static int tolua_CEGUI_CEGUI_Element_setHorizontalAlignment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  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: getHorizontalAlignment of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getHorizontalAlignment00
static int tolua_CEGUI_CEGUI_Element_getHorizontalAlignment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setVerticalAlignment00
static int tolua_CEGUI_CEGUI_Element_setVerticalAlignment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  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: getVerticalAlignment of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getVerticalAlignment00
static int tolua_CEGUI_CEGUI_Element_getVerticalAlignment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  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: setSize of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setSize00
static int tolua_CEGUI_CEGUI_Element_setSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::USize",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::USize* size = ((const CEGUI::USize*)  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: getSize of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getSize00
static int tolua_CEGUI_CEGUI_Element_getSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSize'",NULL);
#endif
 {
  CEGUI::USize tolua_ret = (CEGUI::USize)  self->getSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::USize(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::USize");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::USize));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::USize");
#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: setWidth of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setWidth00
static int tolua_CEGUI_CEGUI_Element_setWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",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::Element* self = (CEGUI::Element*)  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: getWidth of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getWidth00
static int tolua_CEGUI_CEGUI_Element_getWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  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: setHeight of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setHeight00
static int tolua_CEGUI_CEGUI_Element_setHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",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::Element* self = (CEGUI::Element*)  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: getHeight of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getHeight00
static int tolua_CEGUI_CEGUI_Element_getHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  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: setMinSize of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setMinSize00
static int tolua_CEGUI_CEGUI_Element_setMinSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::USize",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::USize* size = ((const CEGUI::USize*)  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: getMinSize of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getMinSize00
static int tolua_CEGUI_CEGUI_Element_getMinSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMinSize'",NULL);
#endif
 {
  const CEGUI::USize& tolua_ret = (const CEGUI::USize&)  self->getMinSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::USize");
 }
 }
 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: setMaxSize of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setMaxSize00
static int tolua_CEGUI_CEGUI_Element_setMaxSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::USize",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::USize* size = ((const CEGUI::USize*)  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: getMaxSize of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getMaxSize00
static int tolua_CEGUI_CEGUI_Element_getMaxSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMaxSize'",NULL);
#endif
 {
  const CEGUI::USize& tolua_ret = (const CEGUI::USize&)  self->getMaxSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::USize");
 }
 }
 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: setAspectMode of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setAspectMode00
static int tolua_CEGUI_CEGUI_Element_setAspectMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::AspectMode mode = ((CEGUI::AspectMode) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAspectMode'",NULL);
#endif
 {
  self->setAspectMode(mode);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAspectMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: setPixelAligned of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setPixelAligned00
static int tolua_CEGUI_CEGUI_Element_setPixelAligned00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  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 'setPixelAligned'",NULL);
#endif
 {
  self->setPixelAligned(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPixelAligned'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: getPixelSize of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getPixelSize00
static int tolua_CEGUI_CEGUI_Element_getPixelSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPixelSize'",NULL);
#endif
 {
  const CEGUI::Size<float>& tolua_ret = (const CEGUI::Size<float>&)  self->getPixelSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size<float>");
 }
 }
 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: calculatePixelSize of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_calculatePixelSize00
static int tolua_CEGUI_CEGUI_Element_calculatePixelSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",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::Element* self = (const CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
  bool skipAllPixelAlignment = ((bool)  tolua_toboolean(tolua_S,2,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'calculatePixelSize'",NULL);
#endif
 {
  CEGUI::Size<float> tolua_ret = (CEGUI::Size<float>)  self->calculatePixelSize(skipAllPixelAlignment);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'calculatePixelSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getParentPixelSize of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getParentPixelSize00
static int tolua_CEGUI_CEGUI_Element_getParentPixelSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",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::Element* self = (const CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
  bool skipAllPixelAlignment = ((bool)  tolua_toboolean(tolua_S,2,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getParentPixelSize'",NULL);
#endif
 {
  CEGUI::Size<float> tolua_ret = (CEGUI::Size<float>)  self->getParentPixelSize(skipAllPixelAlignment);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#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: getRotation of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getRotation00
static int tolua_CEGUI_CEGUI_Element_getRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRotation'",NULL);
#endif
 {
  const CEGUI::Quaternion& tolua_ret = (const CEGUI::Quaternion&)  self->getRotation();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Quaternion");
 }
 }
 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: addChild of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_addChild00
static int tolua_CEGUI_CEGUI_Element_addChild00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Element* element = ((CEGUI::Element*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addChild'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->addChild(element);
 }
catch(CEGUI::InvalidRequestException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::InvalidRequestException' was thrown by function 'addChild'\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 'addChild'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getChildElementAtIdx of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getChildElementAtIdx00
static int tolua_CEGUI_CEGUI_Element_getChildElementAtIdx00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",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::Element* self = (const CEGUI::Element*)  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 'getChildElementAtIdx'",NULL);
#endif
 {
  CEGUI::Element* tolua_ret = (CEGUI::Element*)  self->getChildElementAtIdx(idx);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Element");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getChildElementAtIdx'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildCount of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getChildCount00
static int tolua_CEGUI_CEGUI_Element_getChildCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_isChild00
static int tolua_CEGUI_CEGUI_Element_isChild00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Element* element = ((const CEGUI::Element*)  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(element);
 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: isAncestor of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_isAncestor00
static int tolua_CEGUI_CEGUI_Element_isAncestor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Element* element = ((const CEGUI::Element*)  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(element);
 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: setNonClient of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setNonClient00
static int tolua_CEGUI_CEGUI_Element_setNonClient00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  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 'setNonClient'",NULL);
#endif
 {
  self->setNonClient(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNonClient'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getUnclippedOuterRect of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getUnclippedOuterRect00
static int tolua_CEGUI_CEGUI_Element_getUnclippedOuterRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUnclippedOuterRect'",NULL);
#endif
 {
  const CEGUI::Element::CachedRectf& tolua_ret = (const CEGUI::Element::CachedRectf&)  self->getUnclippedOuterRect();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Element::CachedRectf");
 }
 }
 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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getUnclippedInnerRect00
static int tolua_CEGUI_CEGUI_Element_getUnclippedInnerRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUnclippedInnerRect'",NULL);
#endif
 {
  const CEGUI::Element::CachedRectf& tolua_ret = (const CEGUI::Element::CachedRectf&)  self->getUnclippedInnerRect();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Element::CachedRectf");
 }
 }
 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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getUnclippedRect00
static int tolua_CEGUI_CEGUI_Element_getUnclippedRect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",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::Element* self = (const CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
  const bool inner = ((const bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUnclippedRect'",NULL);
#endif
 {
  const CEGUI::Element::CachedRectf& tolua_ret = (const CEGUI::Element::CachedRectf&)  self->getUnclippedRect(inner);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Element::CachedRectf");
 }
 }
 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: getClientChildContentArea of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getClientChildContentArea00
static int tolua_CEGUI_CEGUI_Element_getClientChildContentArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getClientChildContentArea'",NULL);
#endif
 {
  const CEGUI::Element::CachedRectf& tolua_ret = (const CEGUI::Element::CachedRectf&)  self->getClientChildContentArea();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Element::CachedRectf");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getClientChildContentArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getChildContentArea of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getChildContentArea00
static int tolua_CEGUI_CEGUI_Element_getChildContentArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",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::Element* self = (const CEGUI::Element*)  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 'getChildContentArea'",NULL);
#endif
 {
  const CEGUI::Element::CachedRectf& tolua_ret = (const CEGUI::Element::CachedRectf&)  self->getChildContentArea(non_client);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Element::CachedRectf");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getChildContentArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: setProperty of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setProperty00
static int tolua_CEGUI_CEGUI_Element_setProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",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::Element* self = (CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getProperty00
static int tolua_CEGUI_CEGUI_Element_getProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",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::Element* self = (const CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getPropertyDefault00
static int tolua_CEGUI_CEGUI_Element_getPropertyDefault00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",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::Element* self = (const CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getPropertyHelp00
static int tolua_CEGUI_CEGUI_Element_getPropertyHelp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",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::Element* self = (const CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_isPropertyPresent00
static int tolua_CEGUI_CEGUI_Element_isPropertyPresent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",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::Element* self = (const CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_isPropertyDefault00
static int tolua_CEGUI_CEGUI_Element_isPropertyDefault00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",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::Element* self = (const CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getPropertyIterator00
static int tolua_CEGUI_CEGUI_Element_getPropertyIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_addEvent00
static int tolua_CEGUI_CEGUI_Element_addEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_removeEvent00
static int tolua_CEGUI_CEGUI_Element_removeEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_removeAllEvents00
static int tolua_CEGUI_CEGUI_Element_removeAllEvents00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_isEventPresent00
static int tolua_CEGUI_CEGUI_Element_isEventPresent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_subscribeEvent00
static int tolua_CEGUI_CEGUI_Element_subscribeEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_subscribeEvent01
static int tolua_CEGUI_CEGUI_Element_subscribeEvent01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",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::Element* self = (CEGUI::Element*)  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_Element_subscribeEvent00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: fireEvent of class  CEGUI::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_fireEvent00
static int tolua_CEGUI_CEGUI_Element_fireEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",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::Element* self = (CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_isMuted00
static int tolua_CEGUI_CEGUI_Element_isMuted00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_setMutedState00
static int tolua_CEGUI_CEGUI_Element_setMutedState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Element",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Element* self = (CEGUI::Element*)  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::Element */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Element_getEventIterator00
static int tolua_CEGUI_CEGUI_Element_getEventIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Element",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Element* self = (const CEGUI::Element*)  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: new of class  CEGUI::NamedElementEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedElementEventArgs_new00
static int tolua_CEGUI_CEGUI_NamedElementEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::NamedElementEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::NamedElement",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::NamedElement* element = ((CEGUI::NamedElement*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::NamedElementEventArgs* tolua_ret = (CEGUI::NamedElementEventArgs*)  new CEGUI::NamedElementEventArgs(element);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::NamedElementEventArgs");
 }
 }
 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::NamedElementEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedElementEventArgs_new00_local
static int tolua_CEGUI_CEGUI_NamedElementEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::NamedElementEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::NamedElement",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::NamedElement* element = ((CEGUI::NamedElement*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::NamedElementEventArgs* tolua_ret = (CEGUI::NamedElementEventArgs*)  new CEGUI::NamedElementEventArgs(element);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::NamedElementEventArgs");
 }
 }
 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: element of class  CEGUI::NamedElementEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__NamedElementEventArgs_element_ptr
static int tolua_get_CEGUI__NamedElementEventArgs_element_ptr(lua_State* tolua_S)
{
  CEGUI::NamedElementEventArgs* self = (CEGUI::NamedElementEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'element'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)self->element,"CEGUI::NamedElement");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: new of class  CEGUI::NamedElement */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedElement_new00
static int tolua_CEGUI_CEGUI_NamedElement_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::NamedElement",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,""));
 {
  CEGUI::NamedElement* tolua_ret = (CEGUI::NamedElement*)  new CEGUI::NamedElement(name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::NamedElement");
 }
 }
 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::NamedElement */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedElement_new00_local
static int tolua_CEGUI_CEGUI_NamedElement_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::NamedElement",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,""));
 {
  CEGUI::NamedElement* tolua_ret = (CEGUI::NamedElement*)  new CEGUI::NamedElement(name);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::NamedElement");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setName of class  CEGUI::NamedElement */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedElement_setName00
static int tolua_CEGUI_CEGUI_NamedElement_setName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::NamedElement",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::NamedElement* self = (CEGUI::NamedElement*)  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 'setName'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  self->setName(name);
 }
catch(CEGUI::AlreadyExistsException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::AlreadyExistsException' was thrown by function 'setName'\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 'setName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: isChild of class  CEGUI::NamedElement */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedElement_isChild00
static int tolua_CEGUI_CEGUI_NamedElement_isChild00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::NamedElement",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::NamedElement* self = (const CEGUI::NamedElement*)  tolua_tousertype(tolua_S,1,0);
  utf8string name_path = ((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_path);
 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: isAncestor of class  CEGUI::NamedElement */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedElement_isAncestor00
static int tolua_CEGUI_CEGUI_NamedElement_isAncestor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::NamedElement",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::NamedElement* self = (const CEGUI::NamedElement*)  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;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isAncestor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildElement of class  CEGUI::NamedElement */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedElement_getChildElement00
static int tolua_CEGUI_CEGUI_NamedElement_getChildElement00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::NamedElement",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::NamedElement* self = (const CEGUI::NamedElement*)  tolua_tousertype(tolua_S,1,0);
  utf8string name_path = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getChildElement'",NULL);
#endif
 try
 {
  CEGUI::NamedElement* tolua_ret = (CEGUI::NamedElement*)  self->getChildElement(name_path);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::NamedElement");
 }
catch(CEGUI::UnknownObjectException CEGUIDeadException(&e))
{
 return 0;
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getChildElement'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeChild of class  CEGUI::NamedElement */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_NamedElement_removeChild00
static int tolua_CEGUI_CEGUI_NamedElement_removeChild00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::NamedElement",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::NamedElement* self = (CEGUI::NamedElement*)  tolua_tousertype(tolua_S,1,0);
  utf8string name_path = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeChild'",NULL);
#endif
 {
  self->removeChild(name_path);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeChild'.",&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: setAutoWindow of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setAutoWindow00
static int tolua_CEGUI_CEGUI_Window_setAutoWindow00(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 is_auto = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoWindow'",NULL);
#endif
 {
  self->setAutoWindow(is_auto);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoWindow'.",&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_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 '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: isEffectiveDisabled of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isEffectiveDisabled00
static int tolua_CEGUI_CEGUI_Window_isEffectiveDisabled00(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 'isEffectiveDisabled'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isEffectiveDisabled();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isEffectiveDisabled'.",&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_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 '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: isEffectiveVisible of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isEffectiveVisible00
static int tolua_CEGUI_CEGUI_Window_isEffectiveVisible00(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 'isEffectiveVisible'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isEffectiveVisible();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isEffectiveVisible'.",&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: setDisabled of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setDisabled00
static int tolua_CEGUI_CEGUI_Window_setDisabled00(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 '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: 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: 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: 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: 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: 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,"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 '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: getActiveChild of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getActiveChild01
static int tolua_CEGUI_CEGUI_Window_getActiveChild01(lua_State* tolua_S)
{
 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
 {
  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
 {
  const CEGUI::Window* tolua_ret = (const CEGUI::Window*)  self->getActiveChild();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const CEGUI::Window");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_getActiveChild00(tolua_S);
}
#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: 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: 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: 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 long idx = ((unsigned long)  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(idx);
 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: 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_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_path = ((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_path);
 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_isnumber(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);
  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;
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_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_path = ((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_path);
 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_isnumber(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);
  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;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_getChildRecursive00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: createChild of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_createChild00
static int tolua_CEGUI_CEGUI_Window_createChild00(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,1,&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 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 'createChild'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->createChild(type,name);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::Window");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createChild'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyChild of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_destroyChild00
static int tolua_CEGUI_CEGUI_Window_destroyChild00(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::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);
  CEGUI::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyChild'",NULL);
#endif
 {
  self->destroyChild(wnd);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyChild'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyChild of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_destroyChild01
static int tolua_CEGUI_CEGUI_Window_destroyChild01(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_path = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyChild'",NULL);
#endif
 {
  self->destroyChild(name_path);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_destroyChild00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeChild of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_removeChild00
static int tolua_CEGUI_CEGUI_Window_removeChild00(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 'removeChild'",NULL);
#endif
 {
  self->removeChild(ID);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeChild'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeChild of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_removeChild01
static int tolua_CEGUI_CEGUI_Window_removeChild01(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* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeChild'",NULL);
#endif
 {
  self->removeChild(wnd);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_removeChild00(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_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 useDefault = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getFont'",NULL);
#endif
 {
  const CEGUI::Font* tolua_ret = (const CEGUI::Font*)  self->getFont(useDefault);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const 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: 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_isusertype(tolua_S,2,"const CEGUI::Font",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::Font* font = ((const 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::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_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 'setFont'",NULL);
#endif
 {
  self->setFont(name);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_setFont00(tolua_S);
}
#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: getTextVisual of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getTextVisual00
static int tolua_CEGUI_CEGUI_Window_getTextVisual00(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 'getTextVisual'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getTextVisual();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTextVisual'.",&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: 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: 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: 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: 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: 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);
  const float alpha = ((const 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: 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
 {
  const CEGUI::Rect<float>& tolua_ret = (const CEGUI::Rect<float>&)  self->getOuterRectClipper();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Rect<float>");
 }
 }
 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
 {
  const CEGUI::Rect<float>& tolua_ret = (const CEGUI::Rect<float>&)  self->getInnerRectClipper();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Rect<float>");
 }
 }
 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
 {
  const CEGUI::Rect<float>& tolua_ret = (const CEGUI::Rect<float>&)  self->getClipRect(non_client);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Rect<float>");
 }
 }
 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
 {
  const CEGUI::Rect<float>& tolua_ret = (const CEGUI::Rect<float>&)  self->getHitTestRect();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Rect<float>");
 }
 }
 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: 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_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 'getCaptureWindow'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->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: 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<float>",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);
  const CEGUI::Vector2<float>* position = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
  bool allow_disabled = ((bool)  tolua_toboolean(tolua_S,3,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isHit'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isHit(*position,allow_disabled);
 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: 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<float>",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<float>* position = ((const CEGUI::Vector2<float>*)  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(*position);
 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<float>",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);
  const CEGUI::Vector2<float>* position = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
  bool allow_disabled = ((bool)  tolua_toboolean(tolua_S,3,false));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTargetChildAtPosition'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getTargetChildAtPosition(*position,allow_disabled);
 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: 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_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 useDefault = ((bool)  tolua_toboolean(tolua_S,2,true));
#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(useDefault);
 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_isusertype(tolua_S,2,"const CEGUI::Image",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::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;
#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_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 'setMouseCursor'",NULL);
#endif
 {
  self->setMouseCursor(name);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_setMouseCursor00(tolua_S);
}
#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: setRestoreOldCapture of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setRestoreOldCapture00
static int tolua_CEGUI_CEGUI_Window_setRestoreOldCapture00(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 'setRestoreOldCapture'",NULL);
#endif
 {
  self->setRestoreOldCapture(setting);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRestoreOldCapture'.",&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: 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 long tolua_ret = (unsigned long)  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: 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: 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: 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: 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: 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: 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: 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: 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: 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);
  const bool enabled = ((const 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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 look = ((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(look);
 }
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: setFalagardType of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setFalagardType00
static int tolua_CEGUI_CEGUI_Window_setFalagardType00(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,1,&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 type = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string rendererType = ((utf8string)  tolua_toutf8string(tolua_S,3,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFalagardType'",NULL);
#endif
 {
  self->setFalagardType(type,rendererType);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFalagardType'.",&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: 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: 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: 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: 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: 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: 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: banPropertyFromXML of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_banPropertyFromXML01
static int tolua_CEGUI_CEGUI_Window_banPropertyFromXML01(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::Property",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::Property* property = ((const CEGUI::Property*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'banPropertyFromXML'",NULL);
#endif
 {
  self->banPropertyFromXML(property);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_banPropertyFromXML00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: unbanPropertyFromXML of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_unbanPropertyFromXML01
static int tolua_CEGUI_CEGUI_Window_unbanPropertyFromXML01(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::Property",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::Property* property = ((const CEGUI::Property*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unbanPropertyFromXML'",NULL);
#endif
 {
  self->unbanPropertyFromXML(property);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_unbanPropertyFromXML00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: isPropertyBannedFromXML of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_isPropertyBannedFromXML01
static int tolua_CEGUI_CEGUI_Window_isPropertyBannedFromXML01(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::Property",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::Property* property = ((const CEGUI::Property*)  tolua_tousertype(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);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_isPropertyBannedFromXML00(tolua_S);
}
#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: 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: 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: invalidate of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_invalidate01
static int tolua_CEGUI_CEGUI_Window_invalidate01(lua_State* tolua_S)
{
 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
 {
  CEGUI::Window* self = (CEGUI::Window*)  tolua_tousertype(tolua_S,1,0);
  const bool recursive = ((const bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'invalidate'",NULL);
#endif
 {
  self->invalidate(recursive);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Window_invalidate00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: notifyScreenAreaChanged of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_notifyScreenAreaChanged00
static int tolua_CEGUI_CEGUI_Window_notifyScreenAreaChanged00(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,1,&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 recursive = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'notifyScreenAreaChanged'",NULL);
#endif
 {
  self->notifyScreenAreaChanged(recursive);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'notifyScreenAreaChanged'.",&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);
  const bool setting = ((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(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: getMargin of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getMargin00
static int tolua_CEGUI_CEGUI_Window_getMargin00(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 'getMargin'",NULL);
#endif
 {
  const CEGUI::UBox& tolua_ret = (const CEGUI::UBox&)  self->getMargin();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::UBox");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMargin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setMargin of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_setMargin00
static int tolua_CEGUI_CEGUI_Window_setMargin00(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::UBox",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::UBox* margin = ((const CEGUI::UBox*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMargin'",NULL);
#endif
 {
  self->setMargin(*margin);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMargin'.",&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<float>",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<float>* pos = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUnprojectedPosition'",NULL);
#endif
 {
  CEGUI::Vector2<float> tolua_ret = (CEGUI::Vector2<float>)  self->getUnprojectedPosition(*pos);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#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: 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: 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: 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_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);
  const bool deepCopy = ((const bool)  tolua_toboolean(tolua_S,2,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(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: clonePropertiesTo of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_clonePropertiesTo00
static int tolua_CEGUI_CEGUI_Window_clonePropertiesTo00(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::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);
  CEGUI::Window* target = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clonePropertiesTo'",NULL);
#endif
 {
  self->clonePropertiesTo(*target);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'clonePropertiesTo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: cloneChildWidgetsTo of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_cloneChildWidgetsTo00
static int tolua_CEGUI_CEGUI_Window_cloneChildWidgetsTo00(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::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);
  CEGUI::Window* target = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cloneChildWidgetsTo'",NULL);
#endif
 {
  self->cloneChildWidgetsTo(*target);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'cloneChildWidgetsTo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getGUIContext of class  CEGUI::Window */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Window_getGUIContext00
static int tolua_CEGUI_CEGUI_Window_getGUIContext00(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 'getGUIContext'",NULL);
#endif
 {
  CEGUI::GUIContext& tolua_ret = (CEGUI::GUIContext&)  self->getGUIContext();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::GUIContext");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getGUIContext'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: asAbsolute of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_asAbsolute00
static int tolua_CEGUI_CEGUI_CoordConverter_asAbsolute00(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::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* u = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
  float base = ((float)  tolua_tonumber(tolua_S,3,0));
 {
  float tolua_ret = (float)  CEGUI::CoordConverter::asAbsolute(*u,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::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_asRelative00
static int tolua_CEGUI_CEGUI_CoordConverter_asRelative00(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::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* u = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
  float base = ((float)  tolua_tonumber(tolua_S,3,0));
 {
  float tolua_ret = (float)  CEGUI::CoordConverter::asRelative(*u,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: asAbsolute of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_asAbsolute01
static int tolua_CEGUI_CEGUI_CoordConverter_asAbsolute01(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::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UVector2* v = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Size<float>* base = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Vector2<float> tolua_ret = (CEGUI::Vector2<float>)  CEGUI::CoordConverter::asAbsolute(*v,*base);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_asAbsolute00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: asRelative of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_asRelative01
static int tolua_CEGUI_CEGUI_CoordConverter_asRelative01(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::UVector2",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::UVector2* v = ((const CEGUI::UVector2*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Size<float>* base = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Vector2<float> tolua_ret = (CEGUI::Vector2<float>)  CEGUI::CoordConverter::asRelative(*v,*base);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_asRelative00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: asAbsolute of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_asAbsolute02
static int tolua_CEGUI_CEGUI_CoordConverter_asAbsolute02(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::URect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::URect* r = ((const CEGUI::URect*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Size<float>* base = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Rect<float> tolua_ret = (CEGUI::Rect<float>)  CEGUI::CoordConverter::asAbsolute(*r,*base);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_asAbsolute01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: asRelative of class  CEGUI::CoordConverter */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_CoordConverter_asRelative02
static int tolua_CEGUI_CEGUI_CoordConverter_asRelative02(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::URect",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  const CEGUI::URect* r = ((const CEGUI::URect*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Size<float>* base = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Rect<float> tolua_ret = (CEGUI::Rect<float>)  CEGUI::CoordConverter::asRelative(*r,*base);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_asRelative01(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<float> tolua_ret = (CEGUI::Vector2<float>)  CEGUI::CoordConverter::screenToWindow(*window,*vec);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#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<float>",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<float>* vec = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Vector2<float> tolua_ret = (CEGUI::Vector2<float>)  CEGUI::CoordConverter::screenToWindow(*window,*vec);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#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<float> tolua_ret = (CEGUI::Rect<float>)  CEGUI::CoordConverter::screenToWindow(*window,*rect);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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<float>",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<float>* rect = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,3,0));
 {
  CEGUI::Rect<float> tolua_ret = (CEGUI::Rect<float>)  CEGUI::CoordConverter::screenToWindow(*window,*rect);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#endif
 }
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_CoordConverter_screenToWindow02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMajorVersion of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getMajorVersion00
static int tolua_CEGUI_CEGUI_System_getMajorVersion00(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
 {
 {
  unsigned int tolua_ret = (unsigned int)  CEGUI::System::getMajorVersion();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMajorVersion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMinorVersion of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getMinorVersion00
static int tolua_CEGUI_CEGUI_System_getMinorVersion00(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
 {
 {
  unsigned int tolua_ret = (unsigned int)  CEGUI::System::getMinorVersion();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMinorVersion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPatchVersion of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getPatchVersion00
static int tolua_CEGUI_CEGUI_System_getPatchVersion00(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
 {
 {
  unsigned int tolua_ret = (unsigned int)  CEGUI::System::getPatchVersion();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPatchVersion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVersion of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getVersion00
static int tolua_CEGUI_CEGUI_System_getVersion00(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
 {
 {
  const string tolua_ret = (const string)  CEGUI::System::getVersion();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVersion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVerboseVersion of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getVerboseVersion00
static int tolua_CEGUI_CEGUI_System_getVerboseVersion00(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
 {
 {
  const string tolua_ret = (const string)  CEGUI::System::getVerboseVersion();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVerboseVersion'.",&tolua_err);
 return 0;
#endif
}
#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: getDefaultGUIContext of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getDefaultGUIContext00
static int tolua_CEGUI_CEGUI_System_getDefaultGUIContext00(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 'getDefaultGUIContext'",NULL);
#endif
 {
  CEGUI::GUIContext& tolua_ret = (CEGUI::GUIContext&)  self->getDefaultGUIContext();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::GUIContext");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultGUIContext'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: renderAllGUIContexts of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_renderAllGUIContexts00
static int tolua_CEGUI_CEGUI_System_renderAllGUIContexts00(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 'renderAllGUIContexts'",NULL);
#endif
 {
  self->renderAllGUIContexts();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'renderAllGUIContexts'.",&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_isutf8string(tolua_S,3,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&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));
  utf8string resourceGroup = ((utf8string)  tolua_toutf8string(tolua_S,3,""));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'executeScriptFile'",NULL);
#endif
 {
  self->executeScriptFile(filename,resourceGroup);
 }
 }
 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 function_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(function_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 str = ((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(str);
 }
 }
 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: 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<float>",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<float>* new_size = ((const CEGUI::Size<float>*)  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: invalidateAllCachedRendering of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_invalidateAllCachedRendering00
static int tolua_CEGUI_CEGUI_System_invalidateAllCachedRendering00(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 'invalidateAllCachedRendering'",NULL);
#endif
 {
  self->invalidateAllCachedRendering();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'invalidateAllCachedRendering'.",&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: createGUIContext of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_createGUIContext00
static int tolua_CEGUI_CEGUI_System_createGUIContext00(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::RenderTarget",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::RenderTarget* rt = ((CEGUI::RenderTarget*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createGUIContext'",NULL);
#endif
 {
  CEGUI::GUIContext& tolua_ret = (CEGUI::GUIContext&)  self->createGUIContext(*rt);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::GUIContext");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createGUIContext'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyGUIContext of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_destroyGUIContext00
static int tolua_CEGUI_CEGUI_System_destroyGUIContext00(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::GUIContext",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::GUIContext* context = ((CEGUI::GUIContext*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyGUIContext'",NULL);
#endif
 {
  self->destroyGUIContext(*context);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyGUIContext'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addStandardWindowFactories of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_addStandardWindowFactories00
static int tolua_CEGUI_CEGUI_System_addStandardWindowFactories00(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 'addStandardWindowFactories'",NULL);
#endif
 {
  self->addStandardWindowFactories();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addStandardWindowFactories'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getStringTranscoder of class  CEGUI::System */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_System_getStringTranscoder00
static int tolua_CEGUI_CEGUI_System_getStringTranscoder00(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
 {
 {
  const CEGUI::StringTranscoder& tolua_ret = (const CEGUI::StringTranscoder&)  CEGUI::System::getStringTranscoder();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::StringTranscoder");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getStringTranscoder'.",&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: new of class  CEGUI::GUIContextEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContextEventArgs_new00
static int tolua_CEGUI_CEGUI_GUIContextEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::GUIContextEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* context = ((CEGUI::GUIContext*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::GUIContextEventArgs* tolua_ret = (CEGUI::GUIContextEventArgs*)  new CEGUI::GUIContextEventArgs(context);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::GUIContextEventArgs");
 }
 }
 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::GUIContextEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContextEventArgs_new00_local
static int tolua_CEGUI_CEGUI_GUIContextEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::GUIContextEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* context = ((CEGUI::GUIContext*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::GUIContextEventArgs* tolua_ret = (CEGUI::GUIContextEventArgs*)  new CEGUI::GUIContextEventArgs(context);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::GUIContextEventArgs");
 }
 }
 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: context of class  CEGUI::GUIContextEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__GUIContextEventArgs_context_ptr
static int tolua_get_CEGUI__GUIContextEventArgs_context_ptr(lua_State* tolua_S)
{
  CEGUI::GUIContextEventArgs* self = (CEGUI::GUIContextEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'context'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)self->context,"CEGUI::GUIContext");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getRootWindow of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_getRootWindow00
static int tolua_CEGUI_CEGUI_GUIContext_getRootWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::GUIContext* self = (const CEGUI::GUIContext*)  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;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRootWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRootWindow of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_setRootWindow00
static int tolua_CEGUI_CEGUI_GUIContext_setRootWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",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::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Window* new_root = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRootWindow'",NULL);
#endif
 {
  self->setRootWindow(new_root);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRootWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: getWindowContainingMouse of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_getWindowContainingMouse00
static int tolua_CEGUI_CEGUI_GUIContext_getWindowContainingMouse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::GUIContext* self = (const CEGUI::GUIContext*)  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: getSurfaceSize of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_getSurfaceSize00
static int tolua_CEGUI_CEGUI_GUIContext_getSurfaceSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::GUIContext* self = (const CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSurfaceSize'",NULL);
#endif
 {
  const CEGUI::Size<float>& tolua_ret = (const CEGUI::Size<float>&)  self->getSurfaceSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size<float>");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSurfaceSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: getMouseCursor of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_getMouseCursor00
static int tolua_CEGUI_CEGUI_GUIContext_getMouseCursor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMouseCursor'",NULL);
#endif
 {
  CEGUI::MouseCursor& tolua_ret = (CEGUI::MouseCursor&)  self->getMouseCursor();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::MouseCursor");
 }
 }
 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: setMouseMoveScalingFactor of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_setMouseMoveScalingFactor00
static int tolua_CEGUI_CEGUI_GUIContext_setMouseMoveScalingFactor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
  float factor = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setMouseMoveScalingFactor'",NULL);
#endif
 {
  self->setMouseMoveScalingFactor(factor);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMouseMoveScalingFactor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setMouseButtonClickTimeout of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_setMouseButtonClickTimeout00
static int tolua_CEGUI_CEGUI_GUIContext_setMouseButtonClickTimeout00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  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 'setMouseButtonClickTimeout'",NULL);
#endif
 {
  self->setMouseButtonClickTimeout(seconds);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMouseButtonClickTimeout'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setMouseButtonMultiClickTimeout of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_setMouseButtonMultiClickTimeout00
static int tolua_CEGUI_CEGUI_GUIContext_setMouseButtonMultiClickTimeout00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  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 'setMouseButtonMultiClickTimeout'",NULL);
#endif
 {
  self->setMouseButtonMultiClickTimeout(seconds);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setMouseButtonMultiClickTimeout'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: setMouseClickEventGenerationEnabled of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_setMouseClickEventGenerationEnabled00
static int tolua_CEGUI_CEGUI_GUIContext_setMouseClickEventGenerationEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  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 '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: isMouseClickEventGenerationEnabled of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_isMouseClickEventGenerationEnabled00
static int tolua_CEGUI_CEGUI_GUIContext_isMouseClickEventGenerationEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::GUIContext* self = (const CEGUI::GUIContext*)  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: updateWindowContainingMouse of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_updateWindowContainingMouse00
static int tolua_CEGUI_CEGUI_GUIContext_updateWindowContainingMouse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'updateWindowContainingMouse'",NULL);
#endif
 {
  self->updateWindowContainingMouse();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'updateWindowContainingMouse'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setDefaultTooltipObject of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_setDefaultTooltipObject00
static int tolua_CEGUI_CEGUI_GUIContext_setDefaultTooltipObject00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",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::GUIContext* self = (CEGUI::GUIContext*)  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 'setDefaultTooltipObject'",NULL);
#endif
 {
  self->setDefaultTooltipObject(tooltip);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setDefaultTooltipObject'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: setDefaultFont of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_setDefaultFont00
static int tolua_CEGUI_CEGUI_GUIContext_setDefaultFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  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::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_setDefaultFont01
static int tolua_CEGUI_CEGUI_GUIContext_setDefaultFont01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",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::GUIContext* self = (CEGUI::GUIContext*)  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_GUIContext_setDefaultFont00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDefaultFont of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_getDefaultFont00
static int tolua_CEGUI_CEGUI_GUIContext_getDefaultFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::GUIContext* self = (const CEGUI::GUIContext*)  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: injectMouseMove of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectMouseMove00
static int tolua_CEGUI_CEGUI_GUIContext_injectMouseMove00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",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::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
  float delta_x = ((float)  tolua_tonumber(tolua_S,2,0));
  float delta_y = ((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(delta_x,delta_y);
 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::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectMouseLeaves00
static int tolua_CEGUI_CEGUI_GUIContext_injectMouseLeaves00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  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::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonDown00
static int tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonDown00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MouseButton button = ((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(button);
 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::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonUp00
static int tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonUp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MouseButton button = ((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(button);
 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::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectKeyDown00
static int tolua_CEGUI_CEGUI_GUIContext_injectKeyDown00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Key::Scan scan_code = ((CEGUI::Key::Scan) (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(scan_code);
 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::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectKeyUp00
static int tolua_CEGUI_CEGUI_GUIContext_injectKeyUp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Key::Scan scan_code = ((CEGUI::Key::Scan) (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(scan_code);
 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::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectChar00
static int tolua_CEGUI_CEGUI_GUIContext_injectChar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  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::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectMouseWheelChange00
static int tolua_CEGUI_CEGUI_GUIContext_injectMouseWheelChange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  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::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectMousePosition00
static int tolua_CEGUI_CEGUI_GUIContext_injectMousePosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",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::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
  float x_pos = ((float)  tolua_tonumber(tolua_S,2,0));
  float y_pos = ((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_pos,y_pos);
 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::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectTimePulse00
static int tolua_CEGUI_CEGUI_GUIContext_injectTimePulse00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  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::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonClick00
static int tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonClick00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MouseButton button = ((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(button);
 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::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonDoubleClick00
static int tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonDoubleClick00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MouseButton button = ((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(button);
 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::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonTripleClick00
static int tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonTripleClick00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::MouseButton button = ((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(button);
 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: injectCopyRequest of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectCopyRequest00
static int tolua_CEGUI_CEGUI_GUIContext_injectCopyRequest00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectCopyRequest'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectCopyRequest();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectCopyRequest'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: injectPasteRequest of class  CEGUI::GUIContext */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GUIContext_injectPasteRequest00
static int tolua_CEGUI_CEGUI_GUIContext_injectPasteRequest00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::GUIContext",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::GUIContext* self = (CEGUI::GUIContext*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectPasteRequest'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->injectPasteRequest();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectPasteRequest'.",&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: loadLayoutFromFile of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_loadLayoutFromFile00
static int tolua_CEGUI_CEGUI_WindowManager_loadLayoutFromFile00(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 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 'loadLayoutFromFile'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->loadLayoutFromFile(filename,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 'loadLayoutFromFile'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 catch(std::exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'std::exception' was thrown by function 'loadLayoutFromFile'\nMessage: %s",e.what());
 errorDoIt = true;
}
 catch(...)
{
 snprintf(errorBuffer,512,"Unknown exception thrown by function 'loadLayoutFromFile'");
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadLayoutFromFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: loadLayoutFromString of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_loadLayoutFromString00
static int tolua_CEGUI_CEGUI_WindowManager_loadLayoutFromString00(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 source = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadLayoutFromString'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->loadLayoutFromString(source);
 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 'loadLayoutFromString'\nMessage: %s",e.getMessage().c_str());
 errorDoIt = true;
}
 catch(std::exception&e)
{
 snprintf(errorBuffer,512,"Exception of type 'std::exception' was thrown by function 'loadLayoutFromString'\nMessage: %s",e.what());
 errorDoIt = true;
}
 catch(...)
{
 snprintf(errorBuffer,512,"Unknown exception thrown by function 'loadLayoutFromString'");
 errorDoIt = true;
}
 if (errorDoIt) {
 luaL_error(tolua_S,errorBuffer);
}
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadLayoutFromString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeLayoutToStream of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_writeLayoutToStream00
static int tolua_CEGUI_CEGUI_WindowManager_writeLayoutToStream00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 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_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  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));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeLayoutToStream'",NULL);
#endif
 {
  self->writeLayoutToStream(*window,*out);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeLayoutToStream'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLayoutAsString of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_getLayoutAsString00
static int tolua_CEGUI_CEGUI_WindowManager_getLayoutAsString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 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_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  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));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLayoutAsString'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getLayoutAsString(*window);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLayoutAsString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: saveLayoutToFile of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_saveLayoutToFile00
static int tolua_CEGUI_CEGUI_WindowManager_saveLayoutToFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 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_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  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));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'saveLayoutToFile'",NULL);
#endif
 {
  self->saveLayoutToFile(*window,filename);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'saveLayoutToFile'.",&tolua_err);
 return 0;
#endif
}
#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_isusertype(tolua_S,2,"CEGUI::Window",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);
  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;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyWindow'.",&tolua_err);
 return 0;
#endif
}
#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: isAlive of class  CEGUI::WindowManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowManager_isAlive00
static int tolua_CEGUI_CEGUI_WindowManager_isAlive00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const 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
#endif
 {
  const CEGUI::WindowManager* self = (const 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 'isAlive'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isAlive(window);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isAlive'.",&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: 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: removeAllWindowTypeAliases of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_removeAllWindowTypeAliases00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_removeAllWindowTypeAliases00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowFactoryManager* self = (CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeAllWindowTypeAliases'",NULL);
#endif
 {
  self->removeAllWindowTypeAliases();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeAllWindowTypeAliases'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeAllFalagardWindowMappings of class  CEGUI::WindowFactoryManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WindowFactoryManager_removeAllFalagardWindowMappings00
static int tolua_CEGUI_CEGUI_WindowFactoryManager_removeAllFalagardWindowMappings00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WindowFactoryManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WindowFactoryManager* self = (CEGUI::WindowFactoryManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeAllFalagardWindowMappings'",NULL);
#endif
 {
  self->removeAllFalagardWindowMappings();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeAllFalagardWindowMappings'.",&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: createFromFile of class  CEGUI::SchemeManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeManager_createFromFile00
static int tolua_CEGUI_CEGUI_SchemeManager_createFromFile00(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_isnumber(tolua_S,4,1,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::SchemeManager* self = (CEGUI::SchemeManager*)  tolua_tousertype(tolua_S,1,0);
  utf8string xml_filename = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string resource_group = ((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 'createFromFile'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::Scheme& tolua_ret = (CEGUI::Scheme&)  self->createFromFile(xml_filename,resource_group,action);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Scheme");
 }
catch(CEGUI::AlreadyExistsException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::AlreadyExistsException' was thrown by function 'createFromFile'\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 'createFromFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createFromString of class  CEGUI::SchemeManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SchemeManager_createFromString00
static int tolua_CEGUI_CEGUI_SchemeManager_createFromString00(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_isnumber(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 source = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::XMLResourceExistsAction action = ((CEGUI::XMLResourceExistsAction) (int)  tolua_tonumber(tolua_S,3,CEGUI::XREA_RETURN));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createFromString'",NULL);
#endif
 char errorBuffer[512];
 bool errorDoIt = false;
 try
 {
  CEGUI::Scheme& tolua_ret = (CEGUI::Scheme&)  self->createFromString(source,action);
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Scheme");
 }
catch(CEGUI::AlreadyExistsException&e)
{
 snprintf(errorBuffer,512,"Exception of type 'CEGUI::AlreadyExistsException' was thrown by function 'createFromString'\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 'createFromString'.",&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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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<float> tolua_ret = (CEGUI::Size<float>)  CEGUI::ceguiLua_PropertyHelper::stringToSize(str);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#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: stringToVector2 of class  CEGUI::ceguiLua_PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToVector200
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToVector200(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ceguiLua_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<float> tolua_ret = (CEGUI::Vector2<float>)  CEGUI::ceguiLua_PropertyHelper::stringToVector2(str);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Vector2<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Vector2<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Vector2<float>");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToVector2'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToRect of class  CEGUI::ceguiLua_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::ceguiLua_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<float> tolua_ret = (CEGUI::Rect<float>)  CEGUI::ceguiLua_PropertyHelper::stringToRect(str);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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: stringToUSize of class  CEGUI::ceguiLua_PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToUSize00
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToUSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ceguiLua_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::USize tolua_ret = (CEGUI::USize)  CEGUI::ceguiLua_PropertyHelper::stringToUSize(str);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::USize(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::USize");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::USize));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::USize");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToUSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stringToURect of class  CEGUI::ceguiLua_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::ceguiLua_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::ceguiLua_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: stringToAspectMode of class  CEGUI::ceguiLua_PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_stringToAspectMode00
static int tolua_CEGUI_CEGUI_PropertyHelper_stringToAspectMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ceguiLua_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::AspectMode tolua_ret = (CEGUI::AspectMode)  CEGUI::ceguiLua_PropertyHelper::stringToAspectMode(str);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stringToAspectMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: floatToString of class  CEGUI::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_PropertyHelper",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Size<float>* val = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::ceguiLua_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: vector2ToString of class  CEGUI::ceguiLua_PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_vector2ToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_vector2ToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ceguiLua_PropertyHelper",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Vector2<float>* val = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::ceguiLua_PropertyHelper::vector2ToString(*val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'vector2ToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: rectToString of class  CEGUI::ceguiLua_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::ceguiLua_PropertyHelper",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::Rect<float>* val = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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::ceguiLua_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: usizeToString of class  CEGUI::ceguiLua_PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_usizeToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_usizeToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ceguiLua_PropertyHelper",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::USize",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::USize* val = ((const CEGUI::USize*)  tolua_tousertype(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::ceguiLua_PropertyHelper::usizeToString(*val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'usizeToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: urectToString of class  CEGUI::ceguiLua_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::ceguiLua_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::ceguiLua_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

/* method: aspectModeToString of class  CEGUI::ceguiLua_PropertyHelper */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyHelper_aspectModeToString00
static int tolua_CEGUI_CEGUI_PropertyHelper_aspectModeToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ceguiLua_PropertyHelper",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::AspectMode val = ((CEGUI::AspectMode) (int)  tolua_tonumber(tolua_S,2,0));
 {
  string tolua_ret = (string)  CEGUI::ceguiLua_PropertyHelper::aspectModeToString(val);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'aspectModeToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::RegexMatchStateEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RegexMatchStateEventArgs_new00
static int tolua_CEGUI_CEGUI_RegexMatchStateEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::RegexMatchStateEventArgs",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::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::RegexMatcher::MatchState state = ((CEGUI::RegexMatcher::MatchState) (int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::RegexMatchStateEventArgs* tolua_ret = (CEGUI::RegexMatchStateEventArgs*)  new CEGUI::RegexMatchStateEventArgs(wnd,state);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::RegexMatchStateEventArgs");
 }
 }
 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::RegexMatchStateEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RegexMatchStateEventArgs_new00_local
static int tolua_CEGUI_CEGUI_RegexMatchStateEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::RegexMatchStateEventArgs",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::Window* wnd = ((CEGUI::Window*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::RegexMatcher::MatchState state = ((CEGUI::RegexMatcher::MatchState) (int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::RegexMatchStateEventArgs* tolua_ret = (CEGUI::RegexMatchStateEventArgs*)  new CEGUI::RegexMatchStateEventArgs(wnd,state);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::RegexMatchStateEventArgs");
 }
 }
 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: matchState of class  CEGUI::RegexMatchStateEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__RegexMatchStateEventArgs_matchState
static int tolua_get_CEGUI__RegexMatchStateEventArgs_matchState(lua_State* tolua_S)
{
  CEGUI::RegexMatchStateEventArgs* self = (CEGUI::RegexMatchStateEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'matchState'",NULL);
#endif
 tolua_pushnumber(tolua_S,(lua_Number)self->matchState);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: getMatchStateOfString of class  CEGUI::RegexMatcher */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RegexMatcher_getMatchStateOfString00
static int tolua_CEGUI_CEGUI_RegexMatcher_getMatchStateOfString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RegexMatcher",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::RegexMatcher* self = (const CEGUI::RegexMatcher*)  tolua_tousertype(tolua_S,1,0);
  utf8string str = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMatchStateOfString'",NULL);
#endif
 {
  CEGUI::RegexMatcher::MatchState tolua_ret = (CEGUI::RegexMatcher::MatchState)  self->getMatchStateOfString(str);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMatchStateOfString'.",&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<float>");
 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<float>",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->position = *((CEGUI::Vector3<float>*)  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<float>");
 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<float>",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->tex_coords = *((CEGUI::Vector2<float>*)  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<float>");
 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<float>",0,&tolua_err))
 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->offset = *((CEGUI::Vector2<float>*)  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<float>",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<float>* v = ((const CEGUI::Vector3<float>*)  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::Quaternion",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::Quaternion* r = ((const CEGUI::Quaternion*)  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<float>",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<float>* p = ((const CEGUI::Vector3<float>*)  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: new of class  CEGUI::RenderTargetEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTargetEventArgs_new00
static int tolua_CEGUI_CEGUI_RenderTargetEventArgs_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::RenderTargetEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderTarget* target = ((CEGUI::RenderTarget*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::RenderTargetEventArgs* tolua_ret = (CEGUI::RenderTargetEventArgs*)  new CEGUI::RenderTargetEventArgs(target);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::RenderTargetEventArgs");
 }
 }
 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::RenderTargetEventArgs */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTargetEventArgs_new00_local
static int tolua_CEGUI_CEGUI_RenderTargetEventArgs_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::RenderTargetEventArgs",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderTarget* target = ((CEGUI::RenderTarget*)  tolua_tousertype(tolua_S,2,0));
 {
  CEGUI::RenderTargetEventArgs* tolua_ret = (CEGUI::RenderTargetEventArgs*)  new CEGUI::RenderTargetEventArgs(target);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::RenderTargetEventArgs");
 }
 }
 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: target of class  CEGUI::RenderTargetEventArgs */
#ifndef TOLUA_DISABLE_tolua_get_CEGUI__RenderTargetEventArgs_target_ptr
static int tolua_get_CEGUI__RenderTargetEventArgs_target_ptr(lua_State* tolua_S)
{
  CEGUI::RenderTargetEventArgs* self = (CEGUI::RenderTargetEventArgs*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'target'",NULL);
#endif
 tolua_pushusertype(tolua_S,(void*)self->target,"CEGUI::RenderTarget");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: draw of class  CEGUI::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_draw00
static int tolua_CEGUI_CEGUI_RenderTarget_draw00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderTarget",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::RenderTarget* self = (CEGUI::RenderTarget*)  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 'draw'",NULL);
#endif
 {
  self->draw(*buffer);
 }
 }
 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: draw of class  CEGUI::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_draw01
static int tolua_CEGUI_CEGUI_RenderTarget_draw01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::RenderQueue",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::RenderTarget* self = (CEGUI::RenderTarget*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::RenderQueue* queue = ((const CEGUI::RenderQueue*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'draw'",NULL);
#endif
 {
  self->draw(*queue);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_RenderTarget_draw00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setArea of class  CEGUI::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_setArea00
static int tolua_CEGUI_CEGUI_RenderTarget_setArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Rect<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderTarget* self = (CEGUI::RenderTarget*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Rect<float>* area = ((const CEGUI::Rect<float>*)  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: getArea of class  CEGUI::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_getArea00
static int tolua_CEGUI_CEGUI_RenderTarget_getArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::RenderTarget* self = (const CEGUI::RenderTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getArea'",NULL);
#endif
 {
  const CEGUI::Rect<float>& tolua_ret = (const CEGUI::Rect<float>&)  self->getArea();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Rect<float>");
 }
 }
 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: isImageryCache of class  CEGUI::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_isImageryCache00
static int tolua_CEGUI_CEGUI_RenderTarget_isImageryCache00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::RenderTarget* self = (const CEGUI::RenderTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isImageryCache'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isImageryCache();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isImageryCache'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: activate of class  CEGUI::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_activate00
static int tolua_CEGUI_CEGUI_RenderTarget_activate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderTarget* self = (CEGUI::RenderTarget*)  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::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_deactivate00
static int tolua_CEGUI_CEGUI_RenderTarget_deactivate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderTarget* self = (CEGUI::RenderTarget*)  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: unprojectPoint of class  CEGUI::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_unprojectPoint00
static int tolua_CEGUI_CEGUI_RenderTarget_unprojectPoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::GeometryBuffer",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"CEGUI::Vector2<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::RenderTarget* self = (const CEGUI::RenderTarget*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::GeometryBuffer* buff = ((const CEGUI::GeometryBuffer*)  tolua_tousertype(tolua_S,2,0));
  const CEGUI::Vector2<float>* p_in = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::Vector2<float>* p_out = ((CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'unprojectPoint'",NULL);
#endif
 {
  self->unprojectPoint(*buff,*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: addEvent of class  CEGUI::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_addEvent00
static int tolua_CEGUI_CEGUI_RenderTarget_addEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderTarget* self = (CEGUI::RenderTarget*)  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::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_removeEvent00
static int tolua_CEGUI_CEGUI_RenderTarget_removeEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderTarget* self = (CEGUI::RenderTarget*)  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::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_removeAllEvents00
static int tolua_CEGUI_CEGUI_RenderTarget_removeAllEvents00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderTarget* self = (CEGUI::RenderTarget*)  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::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_isEventPresent00
static int tolua_CEGUI_CEGUI_RenderTarget_isEventPresent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderTarget* self = (CEGUI::RenderTarget*)  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::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_subscribeEvent00
static int tolua_CEGUI_CEGUI_RenderTarget_subscribeEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderTarget* self = (CEGUI::RenderTarget*)  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_3 =  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_3);
 {
#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::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_subscribeEvent01
static int tolua_CEGUI_CEGUI_RenderTarget_subscribeEvent01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderTarget",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::RenderTarget* self = (CEGUI::RenderTarget*)  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_RenderTarget_subscribeEvent00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: fireEvent of class  CEGUI::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_fireEvent00
static int tolua_CEGUI_CEGUI_RenderTarget_fireEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderTarget",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::RenderTarget* self = (CEGUI::RenderTarget*)  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::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_isMuted00
static int tolua_CEGUI_CEGUI_RenderTarget_isMuted00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::RenderTarget* self = (const CEGUI::RenderTarget*)  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::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_setMutedState00
static int tolua_CEGUI_CEGUI_RenderTarget_setMutedState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderTarget* self = (CEGUI::RenderTarget*)  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::RenderTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderTarget_getEventIterator00
static int tolua_CEGUI_CEGUI_RenderTarget_getEventIterator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RenderTarget",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::RenderTarget* self = (const CEGUI::RenderTarget*)  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: 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<float>",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<float>* region = ((const CEGUI::Rect<float>*)  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<float>",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<float>* position = ((const CEGUI::Vector2<float>*)  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<float>",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<float>* size = ((const CEGUI::Size<float>*)  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::Quaternion",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::Quaternion* rotation = ((const CEGUI::Quaternion*)  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<float>",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<float>* pivot = ((const CEGUI::Vector3<float>*)  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<float>& tolua_ret = (const CEGUI::Vector2<float>&)  self->getPosition();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector2<float>");
 }
 }
 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<float>& tolua_ret = (const CEGUI::Size<float>&)  self->getSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size<float>");
 }
 }
 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::Quaternion& tolua_ret = (const CEGUI::Quaternion&)  self->getRotation();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Quaternion");
 }
 }
 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<float>& tolua_ret = (const CEGUI::Vector3<float>&)  self->getPivot();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector3<float>");
 }
 }
 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<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::Vector2<float>",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<float>* p_in = ((const CEGUI::Vector2<float>*)  tolua_tousertype(tolua_S,2,0));
  CEGUI::Vector2<float>* p_out = ((CEGUI::Vector2<float>*)  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: addGeometryBuffer of class  CEGUI::RenderQueue */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderQueue_addGeometryBuffer00
static int tolua_CEGUI_CEGUI_RenderQueue_addGeometryBuffer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderQueue",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::RenderQueue* self = (CEGUI::RenderQueue*)  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 'addGeometryBuffer'",NULL);
#endif
 {
  self->addGeometryBuffer(*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::RenderQueue */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderQueue_removeGeometryBuffer00
static int tolua_CEGUI_CEGUI_RenderQueue_removeGeometryBuffer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderQueue",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::RenderQueue* self = (CEGUI::RenderQueue*)  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 'removeGeometryBuffer'",NULL);
#endif
 {
  self->removeGeometryBuffer(*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: draw of class  CEGUI::RenderQueue */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderQueue_draw00
static int tolua_CEGUI_CEGUI_RenderQueue_draw00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::RenderQueue",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::RenderQueue* self = (const CEGUI::RenderQueue*)  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: reset of class  CEGUI::RenderQueue */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_RenderQueue_reset00
static int tolua_CEGUI_CEGUI_RenderQueue_reset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::RenderQueue",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::RenderQueue* self = (CEGUI::RenderQueue*)  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: getDefaultRenderTarget of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_getDefaultRenderTarget00
static int tolua_CEGUI_CEGUI_Renderer_getDefaultRenderTarget00(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 'getDefaultRenderTarget'",NULL);
#endif
 {
  CEGUI::RenderTarget& tolua_ret = (CEGUI::RenderTarget&)  self->getDefaultRenderTarget();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::RenderTarget");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getDefaultRenderTarget'.",&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: createTextureTarget of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_createTextureTarget00
static int tolua_CEGUI_CEGUI_Renderer_createTextureTarget00(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 'createTextureTarget'",NULL);
#endif
 {
  CEGUI::TextureTarget* tolua_ret = (CEGUI::TextureTarget*)  self->createTextureTarget();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::TextureTarget");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createTextureTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyTextureTarget of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_destroyTextureTarget00
static int tolua_CEGUI_CEGUI_Renderer_destroyTextureTarget00(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::TextureTarget",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::TextureTarget* target = ((CEGUI::TextureTarget*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'destroyTextureTarget'",NULL);
#endif
 {
  self->destroyTextureTarget(target);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyTextureTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: destroyAllTextureTargets of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_destroyAllTextureTargets00
static int tolua_CEGUI_CEGUI_Renderer_destroyAllTextureTargets00(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 'destroyAllTextureTargets'",NULL);
#endif
 {
  self->destroyAllTextureTargets();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'destroyAllTextureTargets'.",&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_isutf8string(tolua_S,2,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);
  utf8string name = ((utf8string)  tolua_toutf8string(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(name);
 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_isutf8string(tolua_S,4,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Renderer* self = (CEGUI::Renderer*)  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,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(name,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_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"const CEGUI::Size<float>",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 name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  const CEGUI::Size<float>* size = ((const CEGUI::Size<float>*)  tolua_tousertype(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(name,*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: destroyTexture of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_destroyTexture01
static int tolua_CEGUI_CEGUI_Renderer_destroyTexture01(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_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::Renderer* self = (CEGUI::Renderer*)  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 'destroyTexture'",NULL);
#endif
 {
  self->destroyTexture(name);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_Renderer_destroyTexture00(tolua_S);
}
#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<float>",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<float>* sz = ((const CEGUI::Size<float>*)  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<float>& tolua_ret = (const CEGUI::Size<float>&)  self->getDisplaySize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size<float>");
 }
 }
 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<float>& tolua_ret = (const CEGUI::Vector2<float>&)  self->getDisplayDPI();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector2<float>");
 }
 }
 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: getTexture of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_getTexture00
static int tolua_CEGUI_CEGUI_Renderer_getTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Renderer",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::Renderer* self = (const CEGUI::Renderer*)  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 'getTexture'",NULL);
#endif
 {
  CEGUI::Texture& tolua_ret = (CEGUI::Texture&)  self->getTexture(name);
 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: isTextureDefined of class  CEGUI::Renderer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Renderer_isTextureDefined00
static int tolua_CEGUI_CEGUI_Renderer_isTextureDefined00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Renderer",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::Renderer* self = (const CEGUI::Renderer*)  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 'isTextureDefined'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isTextureDefined(name);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isTextureDefined'.",&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<float>& tolua_ret = (const CEGUI::Size<float>&)  self->getSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size<float>");
 }
 }
 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<float>& tolua_ret = (const CEGUI::Size<float>&)  self->getOriginalDataSize();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Size<float>");
 }
 }
 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<float>& tolua_ret = (const CEGUI::Vector2<float>&)  self->getTexelScaling();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector2<float>");
 }
 }
 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: isPixelFormatSupported of class  CEGUI::Texture */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Texture_isPixelFormatSupported00
static int tolua_CEGUI_CEGUI_Texture_isPixelFormatSupported00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::Texture",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::Texture* self = (const CEGUI::Texture*)  tolua_tousertype(tolua_S,1,0);
  CEGUI::Texture::PixelFormat fmt = ((CEGUI::Texture::PixelFormat) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isPixelFormatSupported'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isPixelFormatSupported(fmt);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isPixelFormatSupported'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: clear of class  CEGUI::TextureTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextureTarget_clear00
static int tolua_CEGUI_CEGUI_TextureTarget_clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TextureTarget",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TextureTarget* self = (CEGUI::TextureTarget*)  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: getTexture of class  CEGUI::TextureTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextureTarget_getTexture00
static int tolua_CEGUI_CEGUI_TextureTarget_getTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TextureTarget",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TextureTarget* self = (const CEGUI::TextureTarget*)  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: declareRenderSize of class  CEGUI::TextureTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextureTarget_declareRenderSize00
static int tolua_CEGUI_CEGUI_TextureTarget_declareRenderSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::TextureTarget",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Size<float>",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::TextureTarget* self = (CEGUI::TextureTarget*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::Size<float>* sz = ((const CEGUI::Size<float>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'declareRenderSize'",NULL);
#endif
 {
  self->declareRenderSize(*sz);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'declareRenderSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isRenderingInverted of class  CEGUI::TextureTarget */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextureTarget_isRenderingInverted00
static int tolua_CEGUI_CEGUI_TextureTarget_isRenderingInverted00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TextureTarget",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TextureTarget* self = (const CEGUI::TextureTarget*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isRenderingInverted'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isRenderingInverted();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isRenderingInverted'.",&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: autoStepInstances of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_autoStepInstances00
static int tolua_CEGUI_CEGUI_AnimationManager_autoStepInstances00(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 'autoStepInstances'",NULL);
#endif
 {
  self->autoStepInstances(delta);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'autoStepInstances'.",&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: loadAnimationsFromString of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_loadAnimationsFromString00
static int tolua_CEGUI_CEGUI_AnimationManager_loadAnimationsFromString00(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 source = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadAnimationsFromString'",NULL);
#endif
 {
  self->loadAnimationsFromString(source);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadAnimationsFromString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAnimationDefinitionAsString of class  CEGUI::AnimationManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AnimationManager_getAnimationDefinitionAsString00
static int tolua_CEGUI_CEGUI_AnimationManager_getAnimationDefinitionAsString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::AnimationManager",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,2,"const CEGUI::Animation",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);
  const CEGUI::Animation* animation = ((const CEGUI::Animation*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAnimationDefinitionAsString'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getAnimationDefinitionAsString(*animation);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAnimationDefinitionAsString'.",&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::ToggleButton */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ToggleButton_isSelected00
static int tolua_CEGUI_CEGUI_ToggleButton_isSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ToggleButton",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ToggleButton* self = (const CEGUI::ToggleButton*)  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::ToggleButton */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ToggleButton_setSelected00
static int tolua_CEGUI_CEGUI_ToggleButton_setSelected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ToggleButton",0,&tolua_err) ||
 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ToggleButton* self = (CEGUI::ToggleButton*)  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: 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_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::TreeItem* self = (CEGUI::TreeItem*)  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 'setSelectionBrushImage'",NULL);
#endif
 {
  self->setSelectionBrushImage(name);
 }
 }
 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<float>",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<float>* buttonOffset = ((CEGUI::Rect<float>*)  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<float>& tolua_ret = (CEGUI::Rect<float>&)  self->getButtonLocation();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"CEGUI::Rect<float>");
 }
 }
 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<float>",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<float>* offset = ((const CEGUI::Vector2<float>*)  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: getTargetWindow of class  CEGUI::Tooltip */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tooltip_getTargetWindow00
static int tolua_CEGUI_CEGUI_Tooltip_getTargetWindow00(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 'getTargetWindow'",NULL);
#endif
 {
  const CEGUI::Window* tolua_ret = (const CEGUI::Window*)  self->getTargetWindow();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"const 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: 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: 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: 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: 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: positionSelf of class  CEGUI::Tooltip */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tooltip_positionSelf00
static int tolua_CEGUI_CEGUI_Tooltip_positionSelf00(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 'positionSelf'",NULL);
#endif
 {
  self->positionSelf();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'positionSelf'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sizeSelf of class  CEGUI::Tooltip */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tooltip_sizeSelf00
static int tolua_CEGUI_CEGUI_Tooltip_sizeSelf00(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 'sizeSelf'",NULL);
#endif
 {
  self->sizeSelf();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sizeSelf'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTextSize of class  CEGUI::Tooltip */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Tooltip_getTextSize00
static int tolua_CEGUI_CEGUI_Tooltip_getTextSize00(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 'getTextSize'",NULL);
#endif
 {
  CEGUI::Size<float> tolua_ret = (CEGUI::Size<float>)  self->getTextSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#endif
 }
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTextSize'.",&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_isutf8string(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);
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDragCursorImage'",NULL);
#endif
 {
  self->setDragCursorImage(name);
 }
 }
 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_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_setDragCursorImage00(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: getUnitIntervalScrollPosition of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_getUnitIntervalScrollPosition00
static int tolua_CEGUI_CEGUI_Scrollbar_getUnitIntervalScrollPosition00(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 'getUnitIntervalScrollPosition'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getUnitIntervalScrollPosition();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUnitIntervalScrollPosition'.",&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: setUnitIntervalScrollPosition of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_setUnitIntervalScrollPosition00
static int tolua_CEGUI_CEGUI_Scrollbar_setUnitIntervalScrollPosition00(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 'setUnitIntervalScrollPosition'",NULL);
#endif
 {
  self->setUnitIntervalScrollPosition(position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUnitIntervalScrollPosition'.",&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: scrollForwardsByStep of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_scrollForwardsByStep00
static int tolua_CEGUI_CEGUI_Scrollbar_scrollForwardsByStep00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Scrollbar",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Scrollbar* self = (CEGUI::Scrollbar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'scrollForwardsByStep'",NULL);
#endif
 {
  self->scrollForwardsByStep();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'scrollForwardsByStep'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: scrollBackwardsByPage of class  CEGUI::Scrollbar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Scrollbar_scrollBackwardsByPage00
static int tolua_CEGUI_CEGUI_Scrollbar_scrollBackwardsByPage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::Scrollbar",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::Scrollbar* self = (CEGUI::Scrollbar*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'scrollBackwardsByPage'",NULL);
#endif
 {
  self->scrollBackwardsByPage();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'scrollBackwardsByPage'.",&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<float>& tolua_ret = (const CEGUI::Rect<float>&)  self->getContentArea();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Rect<float>");
 }
 }
 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<float>",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<float>* area = ((const CEGUI::Rect<float>*)  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<float> tolua_ret = (CEGUI::Rect<float>)  self->getChildExtentsArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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<float>& tolua_ret = (const CEGUI::Rect<float>&)  self->getContentPaneArea();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Rect<float>");
 }
 }
 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<float>",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<float>* area = ((const CEGUI::Rect<float>*)  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<float> tolua_ret = (CEGUI::Rect<float>)  self->getViewableArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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: getStepSize of class  CEGUI::ProgressBar */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ProgressBar_getStepSize00
static int tolua_CEGUI_CEGUI_ProgressBar_getStepSize00(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 '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: 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: getTextMatchState of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_getTextMatchState00
static int tolua_CEGUI_CEGUI_Editbox_getTextMatchState00(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 'getTextMatchState'",NULL);
#endif
 {
  CEGUI::RegexMatcher::MatchState tolua_ret = (CEGUI::RegexMatcher::MatchState)  self->getTextMatchState();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTextMatchState'.",&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: getCaretIndex of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_getCaretIndex00
static int tolua_CEGUI_CEGUI_Editbox_getCaretIndex00(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 'getCaretIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getCaretIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCaretIndex'.",&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: setCaretIndex of class  CEGUI::Editbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Editbox_setCaretIndex00
static int tolua_CEGUI_CEGUI_Editbox_setCaretIndex00(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 caret_pos = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCaretIndex'",NULL);
#endif
 {
  self->setCaretIndex(caret_pos);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCaretIndex'.",&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: getCaretIndex of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_getCaretIndex00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_getCaretIndex00(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 'getCaretIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getCaretIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCaretIndex'.",&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<float> tolua_ret = (CEGUI::Rect<float>)  self->getTextRenderArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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: setCaretIndex of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_setCaretIndex00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_setCaretIndex00(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 caret_pos = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCaretIndex'",NULL);
#endif
 {
  self->setCaretIndex(caret_pos);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCaretIndex'.",&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: ensureCaretIsVisible of class  CEGUI::MultiLineEditbox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiLineEditbox_ensureCaretIsVisible00
static int tolua_CEGUI_CEGUI_MultiLineEditbox_ensureCaretIsVisible00(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 'ensureCaretIsVisible'",NULL);
#endif
 {
  self->ensureCaretIsVisible();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ensureCaretIsVisible'.",&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_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ListboxItem* self = (CEGUI::ListboxItem*)  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 'setSelectionBrushImage'",NULL);
#endif
 {
  self->setSelectionBrushImage(name);
 }
 }
 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<float> tolua_ret = (CEGUI::Size<float>)  self->getPixelSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#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: getTextMatchState of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getTextMatchState00
static int tolua_CEGUI_CEGUI_Combobox_getTextMatchState00(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 'getTextMatchState'",NULL);
#endif
 {
  CEGUI::RegexMatcher::MatchState tolua_ret = (CEGUI::RegexMatcher::MatchState)  self->getTextMatchState();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTextMatchState'.",&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: getCaretIndex of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getCaretIndex00
static int tolua_CEGUI_CEGUI_Combobox_getCaretIndex00(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 'getCaretIndex'",NULL);
#endif
 {
  unsigned long tolua_ret = (unsigned long)  self->getCaretIndex();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getCaretIndex'.",&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: setCaretIndex of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setCaretIndex00
static int tolua_CEGUI_CEGUI_Combobox_setCaretIndex00(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 caret_pos = ((unsigned long)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCaretIndex'",NULL);
#endif
 {
  self->setCaretIndex(caret_pos);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCaretIndex'.",&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: getAutoSizeListHeightToContent of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getAutoSizeListHeightToContent00
static int tolua_CEGUI_CEGUI_Combobox_getAutoSizeListHeightToContent00(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 'getAutoSizeListHeightToContent'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->getAutoSizeListHeightToContent();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAutoSizeListHeightToContent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAutoSizeListWidthToContent of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_getAutoSizeListWidthToContent00
static int tolua_CEGUI_CEGUI_Combobox_getAutoSizeListWidthToContent00(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 'getAutoSizeListWidthToContent'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->getAutoSizeListWidthToContent();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAutoSizeListWidthToContent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAutoSizeListHeightToContent of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setAutoSizeListHeightToContent00
static int tolua_CEGUI_CEGUI_Combobox_setAutoSizeListHeightToContent00(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 auto_size = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoSizeListHeightToContent'",NULL);
#endif
 {
  self->setAutoSizeListHeightToContent(auto_size);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoSizeListHeightToContent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAutoSizeListWidthToContent of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_setAutoSizeListWidthToContent00
static int tolua_CEGUI_CEGUI_Combobox_setAutoSizeListWidthToContent00(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 auto_size = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoSizeListWidthToContent'",NULL);
#endif
 {
  self->setAutoSizeListWidthToContent(auto_size);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoSizeListWidthToContent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: updateAutoSizedDropList of class  CEGUI::Combobox */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Combobox_updateAutoSizedDropList00
static int tolua_CEGUI_CEGUI_Combobox_updateAutoSizedDropList00(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 'updateAutoSizedDropList'",NULL);
#endif
 {
  self->updateAutoSizedDropList();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'updateAutoSizedDropList'.",&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<float> tolua_ret = (CEGUI::Rect<float>)  self->getListRenderArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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<float>",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<float>* pt = ((const CEGUI::Vector2<float>*)  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: resizeToContent of class  CEGUI::ComboDropList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ComboDropList_resizeToContent00
static int tolua_CEGUI_CEGUI_ComboDropList_resizeToContent00(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_isboolean(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ComboDropList* self = (CEGUI::ComboDropList*)  tolua_tousertype(tolua_S,1,0);
  bool fit_width = ((bool)  tolua_toboolean(tolua_S,2,0));
  bool fit_height = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resizeToContent'",NULL);
#endif
 {
  self->resizeToContent(fit_width,fit_height);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resizeToContent'.",&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<float>& tolua_ret = (const CEGUI::Vector2<float>&)  self->getDragMoveOffset();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::Vector2<float>");
 }
 }
 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<float> tolua_ret = (CEGUI::Rect<float>)  self->getListRenderArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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: ensureRowIsVisible of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_ensureRowIsVisible00
static int tolua_CEGUI_CEGUI_MultiColumnList_ensureRowIsVisible00(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 'ensureRowIsVisible'",NULL);
#endif
 {
  self->ensureRowIsVisible(row_idx);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ensureRowIsVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ensureColumnIsVisible of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_ensureColumnIsVisible00
static int tolua_CEGUI_CEGUI_MultiColumnList_ensureColumnIsVisible00(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 'ensureColumnIsVisible'",NULL);
#endif
 {
  self->ensureColumnIsVisible(col_idx);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ensureColumnIsVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ensureItemRowIsVisible of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_ensureItemRowIsVisible00
static int tolua_CEGUI_CEGUI_MultiColumnList_ensureItemRowIsVisible00(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,"const CEGUI::ListboxItem",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);
  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 'ensureItemRowIsVisible'",NULL);
#endif
 {
  self->ensureItemRowIsVisible(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ensureItemRowIsVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ensureItemColumnIsVisible of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_ensureItemColumnIsVisible00
static int tolua_CEGUI_CEGUI_MultiColumnList_ensureItemColumnIsVisible00(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,"const CEGUI::ListboxItem",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);
  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 'ensureItemColumnIsVisible'",NULL);
#endif
 {
  self->ensureItemColumnIsVisible(item);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ensureItemColumnIsVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ensureItemIsVisible of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_ensureItemIsVisible00
static int tolua_CEGUI_CEGUI_MultiColumnList_ensureItemIsVisible00(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,"const CEGUI::ListboxItem",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);
  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;
#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::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_ensureItemIsVisible01
static int tolua_CEGUI_CEGUI_MultiColumnList_ensureItemIsVisible01(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_isnoobj(tolua_S,3,&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));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ensureItemIsVisible'",NULL);
#endif
 {
  self->ensureItemIsVisible(*grid_ref);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_MultiColumnList_ensureItemIsVisible00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAutoSizeColumnUsesHeader of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_setAutoSizeColumnUsesHeader00
static int tolua_CEGUI_CEGUI_MultiColumnList_setAutoSizeColumnUsesHeader00(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 include_header = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoSizeColumnUsesHeader'",NULL);
#endif
 {
  self->setAutoSizeColumnUsesHeader(include_header);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoSizeColumnUsesHeader'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAutoSizeColumnUsesHeader of class  CEGUI::MultiColumnList */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_MultiColumnList_getAutoSizeColumnUsesHeader00
static int tolua_CEGUI_CEGUI_MultiColumnList_getAutoSizeColumnUsesHeader00(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 'getAutoSizeColumnUsesHeader'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->getAutoSizeColumnUsesHeader();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAutoSizeColumnUsesHeader'.",&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<float> tolua_ret = (CEGUI::Size<float>)  self->getItemPixelSize();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Size<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Size<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Size<float>");
#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<float> tolua_ret = (CEGUI::Rect<float>)  self->getItemRenderArea();
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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: getPositionOfChild of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChild00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChild00(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 'getPositionOfChild'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getPositionOfChild(wnd);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPositionOfChild'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPositionOfChild of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChild01
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChild01(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 'getPositionOfChild'",NULL);
#endif
 {
  unsigned int tolua_ret = (unsigned int)  self->getPositionOfChild(wnd);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChild00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildAtPosition of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_getChildAtPosition00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_getChildAtPosition00(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 'getChildAtPosition'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getChildAtPosition(position);
 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: swapChildPositions of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildPositions00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildPositions00(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 'swapChildPositions'",NULL);
#endif
 {
  self->swapChildPositions(wnd1,wnd2);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'swapChildPositions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildren of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren00(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 'swapChildren'",NULL);
#endif
 {
  self->swapChildren(wnd1,wnd2);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'swapChildren'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildren of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren01
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren01(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 'swapChildren'",NULL);
#endif
 {
  self->swapChildren(wnd1,wnd2);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildren of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren02
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren02(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 'swapChildren'",NULL);
#endif
 {
  self->swapChildren(wnd1,wnd2);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildren of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren03
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren03(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 'swapChildren'",NULL);
#endif
 {
  self->swapChildren(wnd1,wnd2);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveChildToPosition of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildToPosition00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildToPosition00(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 'moveChildToPosition'",NULL);
#endif
 {
  self->moveChildToPosition(wnd,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveChildToPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveChildToPosition of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildToPosition01
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildToPosition01(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 'moveChildToPosition'",NULL);
#endif
 {
  self->moveChildToPosition(wnd,position);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildToPosition00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveChild of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChild00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChild00(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 'moveChild'",NULL);
#endif
 {
  self->moveChild(window,delta);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveChild'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addChildToPosition of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_addChildToPosition00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_addChildToPosition00(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 'addChildToPosition'",NULL);
#endif
 {
  self->addChildToPosition(window,position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addChildToPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeChildFromPosition of class  CEGUI::SequentialLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_SequentialLayoutContainer_removeChildFromPosition00
static int tolua_CEGUI_CEGUI_SequentialLayoutContainer_removeChildFromPosition00(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 'removeChildFromPosition'",NULL);
#endif
 {
  self->removeChildFromPosition(position);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeChildFromPosition'.",&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: addChildToPosition of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_addChildToPosition00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_addChildToPosition00(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 'addChildToPosition'",NULL);
#endif
 {
  self->addChildToPosition(window,gridX,gridY);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addChildToPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getChildAtPosition of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_getChildAtPosition00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_getChildAtPosition00(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 'getChildAtPosition'",NULL);
#endif
 {
  CEGUI::Window* tolua_ret = (CEGUI::Window*)  self->getChildAtPosition(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 'getChildAtPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeChildFromPosition of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_removeChildFromPosition00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_removeChildFromPosition00(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 'removeChildFromPosition'",NULL);
#endif
 {
  self->removeChildFromPosition(gridX,gridY);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeChildFromPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildPositions of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildPositions00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildPositions00(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 'swapChildPositions'",NULL);
#endif
 {
  self->swapChildPositions(wnd1,wnd2);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'swapChildPositions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildPositions of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildPositions01
static int tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildPositions01(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 'swapChildPositions'",NULL);
#endif
 {
  self->swapChildPositions(gridX1,gridY1,gridX2,gridY2);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildPositions00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildren of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildren00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildren00(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 'swapChildren'",NULL);
#endif
 {
  self->swapChildren(wnd1,wnd2);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'swapChildren'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildren of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildren01
static int tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildren01(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 'swapChildren'",NULL);
#endif
 {
  self->swapChildren(wnd1,wnd2);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildren00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: swapChildren of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildren02
static int tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildren02(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 'swapChildren'",NULL);
#endif
 {
  self->swapChildren(wnd1,wnd2);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildren01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveChildToPosition of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildToPosition00
static int tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildToPosition00(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 'moveChildToPosition'",NULL);
#endif
 {
  self->moveChildToPosition(wnd,gridX,gridY);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveChildToPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveChildToPosition of class  CEGUI::GridLayoutContainer */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildToPosition01
static int tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildToPosition01(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 'moveChildToPosition'",NULL);
#endif
 {
  self->moveChildToPosition(wnd,gridX,gridY);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildToPosition00(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<float>",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<float>* container = ((const CEGUI::Rect<float>*)  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: new of class  CEGUI::OperatorDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_OperatorDim_new00
static int tolua_CEGUI_CEGUI_OperatorDim_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::OperatorDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::OperatorDim* tolua_ret = (CEGUI::OperatorDim*)  new CEGUI::OperatorDim();
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::OperatorDim");
 }
 }
 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::OperatorDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_OperatorDim_new00_local
static int tolua_CEGUI_CEGUI_OperatorDim_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::OperatorDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
 {
  CEGUI::OperatorDim* tolua_ret = (CEGUI::OperatorDim*)  new CEGUI::OperatorDim();
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::OperatorDim");
 }
 }
 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::OperatorDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_OperatorDim_new01
static int tolua_CEGUI_CEGUI_OperatorDim_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::OperatorDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::DimensionOperator op = ((CEGUI::DimensionOperator) (int)  tolua_tonumber(tolua_S,2,0));
 {
  CEGUI::OperatorDim* tolua_ret = (CEGUI::OperatorDim*)  new CEGUI::OperatorDim(op);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::OperatorDim");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_OperatorDim_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::OperatorDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_OperatorDim_new01_local
static int tolua_CEGUI_CEGUI_OperatorDim_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::OperatorDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::DimensionOperator op = ((CEGUI::DimensionOperator) (int)  tolua_tonumber(tolua_S,2,0));
 {
  CEGUI::OperatorDim* tolua_ret = (CEGUI::OperatorDim*)  new CEGUI::OperatorDim(op);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::OperatorDim");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_OperatorDim_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CEGUI::OperatorDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_OperatorDim_new02
static int tolua_CEGUI_CEGUI_OperatorDim_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::OperatorDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::DimensionOperator op = ((CEGUI::DimensionOperator) (int)  tolua_tonumber(tolua_S,2,0));
  CEGUI::BaseDim* left = ((CEGUI::BaseDim*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::BaseDim* right = ((CEGUI::BaseDim*)  tolua_tousertype(tolua_S,4,0));
 {
  CEGUI::OperatorDim* tolua_ret = (CEGUI::OperatorDim*)  new CEGUI::OperatorDim(op,left,right);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::OperatorDim");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_OperatorDim_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CEGUI::OperatorDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_OperatorDim_new02_local
static int tolua_CEGUI_CEGUI_OperatorDim_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::OperatorDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isusertype(tolua_S,3,"CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"CEGUI::BaseDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::DimensionOperator op = ((CEGUI::DimensionOperator) (int)  tolua_tonumber(tolua_S,2,0));
  CEGUI::BaseDim* left = ((CEGUI::BaseDim*)  tolua_tousertype(tolua_S,3,0));
  CEGUI::BaseDim* right = ((CEGUI::BaseDim*)  tolua_tousertype(tolua_S,4,0));
 {
  CEGUI::OperatorDim* tolua_ret = (CEGUI::OperatorDim*)  new CEGUI::OperatorDim(op,left,right);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::OperatorDim");
 }
 }
 return 1;
tolua_lerror:
 return tolua_CEGUI_CEGUI_OperatorDim_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setLeftOperand of class  CEGUI::OperatorDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_OperatorDim_setLeftOperand00
static int tolua_CEGUI_CEGUI_OperatorDim_setLeftOperand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::OperatorDim",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::OperatorDim* self = (CEGUI::OperatorDim*)  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 'setLeftOperand'",NULL);
#endif
 {
  self->setLeftOperand(operand);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setLeftOperand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setRightOperand of class  CEGUI::OperatorDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_OperatorDim_setRightOperand00
static int tolua_CEGUI_CEGUI_OperatorDim_setRightOperand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::OperatorDim",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::OperatorDim* self = (CEGUI::OperatorDim*)  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 'setRightOperand'",NULL);
#endif
 {
  self->setRightOperand(operand);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRightOperand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setOperator of class  CEGUI::OperatorDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_OperatorDim_setOperator00
static int tolua_CEGUI_CEGUI_OperatorDim_setOperator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::OperatorDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::OperatorDim* self = (CEGUI::OperatorDim*)  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 'setOperator'",NULL);
#endif
 {
  self->setOperator(op);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setOperator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setNextOperand of class  CEGUI::OperatorDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_OperatorDim_setNextOperand00
static int tolua_CEGUI_CEGUI_OperatorDim_setNextOperand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::OperatorDim",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::OperatorDim* self = (CEGUI::OperatorDim*)  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 'setNextOperand'",NULL);
#endif
 {
  self->setNextOperand(operand);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNextOperand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBaseValue of class  CEGUI::AbsoluteDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AbsoluteDim_setBaseValue00
static int tolua_CEGUI_CEGUI_AbsoluteDim_setBaseValue00(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 'setBaseValue'",NULL);
#endif
 {
  self->setBaseValue(val);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBaseValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBaseValue of class  CEGUI::AbsoluteDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_AbsoluteDim_getBaseValue00
static int tolua_CEGUI_CEGUI_AbsoluteDim_getBaseValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::AbsoluteDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::AbsoluteDim* self = (const CEGUI::AbsoluteDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBaseValue'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getBaseValue();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBaseValue'.",&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: setSourceDimension of class  CEGUI::ImageDimBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageDimBase_setSourceDimension00
static int tolua_CEGUI_CEGUI_ImageDimBase_setSourceDimension00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImageDimBase",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageDimBase* self = (CEGUI::ImageDimBase*)  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: getSourceDimension of class  CEGUI::ImageDimBase */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageDimBase_getSourceDimension00
static int tolua_CEGUI_CEGUI_ImageDimBase_getSourceDimension00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageDimBase",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageDimBase* self = (const CEGUI::ImageDimBase*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSourceDimension'",NULL);
#endif
 {
  CEGUI::DimensionType tolua_ret = (CEGUI::DimensionType)  self->getSourceDimension();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSourceDimension'.",&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_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImageDim* self = (CEGUI::ImageDim*)  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 'setSourceImage'",NULL);
#endif
 {
  self->setSourceImage(name);
 }
 }
 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: getSourceImage of class  CEGUI::ImageDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageDim_getSourceImage00
static int tolua_CEGUI_CEGUI_ImageDim_getSourceImage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::ImageDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageDim* self = (const CEGUI::ImageDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSourceImage'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getSourceImage();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSourceImage'.",&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_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string image_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::DimensionType dim = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::ImageDim* tolua_ret = (CEGUI::ImageDim*)  new CEGUI::ImageDim(image_name,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_isnumber(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  utf8string image_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::DimensionType dim = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::ImageDim* tolua_ret = (CEGUI::ImageDim*)  new CEGUI::ImageDim(image_name,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: setSourceProperty of class  CEGUI::ImagePropertyDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagePropertyDim_setSourceProperty00
static int tolua_CEGUI_CEGUI_ImagePropertyDim_setSourceProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::ImagePropertyDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ImagePropertyDim* self = (CEGUI::ImagePropertyDim*)  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 'setSourceProperty'",NULL);
#endif
 {
  self->setSourceProperty(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setSourceProperty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: new of class  CEGUI::ImagePropertyDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagePropertyDim_new00
static int tolua_CEGUI_CEGUI_ImagePropertyDim_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImagePropertyDim",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 property_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::DimensionType dim = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::ImagePropertyDim* tolua_ret = (CEGUI::ImagePropertyDim*)  new CEGUI::ImagePropertyDim(property_name,dim);
 tolua_pushusertype(tolua_S,(void*)tolua_ret,"CEGUI::ImagePropertyDim");
 }
 }
 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::ImagePropertyDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImagePropertyDim_new00_local
static int tolua_CEGUI_CEGUI_ImagePropertyDim_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertable(tolua_S,1,"CEGUI::ImagePropertyDim",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 property_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  CEGUI::DimensionType dim = ((CEGUI::DimensionType) (int)  tolua_tonumber(tolua_S,3,0));
 {
  CEGUI::ImagePropertyDim* tolua_ret = (CEGUI::ImagePropertyDim*)  new CEGUI::ImagePropertyDim(property_name,dim);
 tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"CEGUI::ImagePropertyDim");
 }
 }
 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: getWidgetName of class  CEGUI::WidgetDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetDim_getWidgetName00
static int tolua_CEGUI_CEGUI_WidgetDim_getWidgetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetDim* self = (const CEGUI::WidgetDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWidgetName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getWidgetName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWidgetName'.",&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: getSourceDimension of class  CEGUI::WidgetDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetDim_getSourceDimension00
static int tolua_CEGUI_CEGUI_WidgetDim_getSourceDimension00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::WidgetDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::WidgetDim* self = (const CEGUI::WidgetDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSourceDimension'",NULL);
#endif
 {
  CEGUI::DimensionType tolua_ret = (CEGUI::DimensionType)  self->getSourceDimension();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSourceDimension'.",&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: getBaseValue of class  CEGUI::UnifiedDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UnifiedDim_getBaseValue00
static int tolua_CEGUI_CEGUI_UnifiedDim_getBaseValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::UnifiedDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::UnifiedDim* self = (const CEGUI::UnifiedDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBaseValue'",NULL);
#endif
 {
  const CEGUI::UDim& tolua_ret = (const CEGUI::UDim&)  self->getBaseValue();
 tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CEGUI::UDim");
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBaseValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBaseValue of class  CEGUI::UnifiedDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UnifiedDim_setBaseValue00
static int tolua_CEGUI_CEGUI_UnifiedDim_setBaseValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::UnifiedDim",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::UnifiedDim* self = (CEGUI::UnifiedDim*)  tolua_tousertype(tolua_S,1,0);
  const CEGUI::UDim* val = ((const CEGUI::UDim*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBaseValue'",NULL);
#endif
 {
  self->setBaseValue(*val);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBaseValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setSourceDimension of class  CEGUI::UnifiedDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_UnifiedDim_setSourceDimension00
static int tolua_CEGUI_CEGUI_UnifiedDim_setSourceDimension00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::UnifiedDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::UnifiedDim* self = (CEGUI::UnifiedDim*)  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::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: getName of class  CEGUI::FontDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontDim_getName00
static int tolua_CEGUI_CEGUI_FontDim_getName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FontDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FontDim* self = (const CEGUI::FontDim*)  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: setName of class  CEGUI::FontDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontDim_setName00
static int tolua_CEGUI_CEGUI_FontDim_setName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontDim* self = (CEGUI::FontDim*)  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 'setName'",NULL);
#endif
 {
  self->setName(name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getFont of class  CEGUI::FontDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontDim_getFont00
static int tolua_CEGUI_CEGUI_FontDim_getFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FontDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FontDim* self = (const CEGUI::FontDim*)  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::FontDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontDim_setFont00
static int tolua_CEGUI_CEGUI_FontDim_setFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontDim* self = (CEGUI::FontDim*)  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: getText of class  CEGUI::FontDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontDim_getText00
static int tolua_CEGUI_CEGUI_FontDim_getText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FontDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FontDim* self = (const CEGUI::FontDim*)  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::FontDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontDim_setText00
static int tolua_CEGUI_CEGUI_FontDim_setText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontDim* self = (CEGUI::FontDim*)  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: getMetric of class  CEGUI::FontDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontDim_getMetric00
static int tolua_CEGUI_CEGUI_FontDim_getMetric00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FontDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::FontDim* self = (const CEGUI::FontDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMetric'",NULL);
#endif
 {
  CEGUI::FontMetricType tolua_ret = (CEGUI::FontMetricType)  self->getMetric();
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMetric'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: setPadding of class  CEGUI::FontDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FontDim_setPadding00
static int tolua_CEGUI_CEGUI_FontDim_setPadding00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FontDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::FontDim* self = (CEGUI::FontDim*)  tolua_tousertype(tolua_S,1,0);
  float padding = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPadding'",NULL);
#endif
 {
  self->setPadding(padding);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPadding'.",&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: getWidgetName of class  CEGUI::PropertyDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyDim_getWidgetName00
static int tolua_CEGUI_CEGUI_PropertyDim_getWidgetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::PropertyDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PropertyDim* self = (const CEGUI::PropertyDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getWidgetName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getWidgetName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWidgetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setWidgetName of class  CEGUI::PropertyDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyDim_setWidgetName00
static int tolua_CEGUI_CEGUI_PropertyDim_setWidgetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PropertyDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PropertyDim* self = (CEGUI::PropertyDim*)  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: getPropertyName of class  CEGUI::PropertyDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyDim_getPropertyName00
static int tolua_CEGUI_CEGUI_PropertyDim_getPropertyName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::PropertyDim",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::PropertyDim* self = (const CEGUI::PropertyDim*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPropertyName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getPropertyName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPropertyName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPropertyName of class  CEGUI::PropertyDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyDim_setPropertyName00
static int tolua_CEGUI_CEGUI_PropertyDim_setPropertyName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PropertyDim",0,&tolua_err) ||
 !tolua_isutf8string(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PropertyDim* self = (CEGUI::PropertyDim*)  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 'setPropertyName'",NULL);
#endif
 {
  self->setPropertyName(property);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPropertyName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: setSourceDimension of class  CEGUI::PropertyDim */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_PropertyDim_setSourceDimension00
static int tolua_CEGUI_CEGUI_PropertyDim_setSourceDimension00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::PropertyDim",0,&tolua_err) ||
 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::PropertyDim* self = (CEGUI::PropertyDim*)  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::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<float> tolua_ret = (CEGUI::Rect<float>)  self->getPixelRect(*wnd);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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<float>",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<float>* container = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPixelRect'",NULL);
#endif
 {
  CEGUI::Rect<float> tolua_ret = (CEGUI::Rect<float>)  self->getPixelRect(*wnd,*container);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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

/* method: setNamedAreaSouce of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ComponentArea_setNamedAreaSouce00
static int tolua_CEGUI_CEGUI_ComponentArea_setNamedAreaSouce00(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_isutf8string(tolua_S,3,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::ComponentArea* self = (CEGUI::ComponentArea*)  tolua_tousertype(tolua_S,1,0);
  utf8string widget_look = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
  utf8string area_name = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setNamedAreaSouce'",NULL);
#endif
 {
  self->setNamedAreaSouce(widget_look,area_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setNamedAreaSouce'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isAreaFetchedFromNamedArea of class  CEGUI::ComponentArea */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ComponentArea_isAreaFetchedFromNamedArea00
static int tolua_CEGUI_CEGUI_ComponentArea_isAreaFetchedFromNamedArea00(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 'isAreaFetchedFromNamedArea'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isAreaFetchedFromNamedArea();
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isAreaFetchedFromNamedArea'.",&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: 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: 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<float>",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<float>* clipper = ((const CEGUI::Rect<float>*)  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<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::Rect<float>",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<float>* baseRect = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::ColourRect* modColours = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Rect<float>* clipper = ((const CEGUI::Rect<float>*)  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: setLeftEdgeFormatting of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setLeftEdgeFormatting00
static int tolua_CEGUI_CEGUI_FrameComponent_setLeftEdgeFormatting00(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 'setLeftEdgeFormatting'",NULL);
#endif
 {
  self->setLeftEdgeFormatting(fmt);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setLeftEdgeFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRightEdgeFormatting of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setRightEdgeFormatting00
static int tolua_CEGUI_CEGUI_FrameComponent_setRightEdgeFormatting00(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 'setRightEdgeFormatting'",NULL);
#endif
 {
  self->setRightEdgeFormatting(fmt);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRightEdgeFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTopEdgeFormatting of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setTopEdgeFormatting00
static int tolua_CEGUI_CEGUI_FrameComponent_setTopEdgeFormatting00(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 'setTopEdgeFormatting'",NULL);
#endif
 {
  self->setTopEdgeFormatting(fmt);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTopEdgeFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBottomEdgeFormatting of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setBottomEdgeFormatting00
static int tolua_CEGUI_CEGUI_FrameComponent_setBottomEdgeFormatting00(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 'setBottomEdgeFormatting'",NULL);
#endif
 {
  self->setBottomEdgeFormatting(fmt);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBottomEdgeFormatting'.",&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: 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: setLeftEdgeFormattingPropertySource of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setLeftEdgeFormattingPropertySource00
static int tolua_CEGUI_CEGUI_FrameComponent_setLeftEdgeFormattingPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isutf8string(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);
  utf8string property_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setLeftEdgeFormattingPropertySource'",NULL);
#endif
 {
  self->setLeftEdgeFormattingPropertySource(property_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setLeftEdgeFormattingPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRightEdgeFormattingPropertySource of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setRightEdgeFormattingPropertySource00
static int tolua_CEGUI_CEGUI_FrameComponent_setRightEdgeFormattingPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isutf8string(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);
  utf8string property_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRightEdgeFormattingPropertySource'",NULL);
#endif
 {
  self->setRightEdgeFormattingPropertySource(property_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setRightEdgeFormattingPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTopEdgeFormattingPropertySource of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setTopEdgeFormattingPropertySource00
static int tolua_CEGUI_CEGUI_FrameComponent_setTopEdgeFormattingPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isutf8string(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);
  utf8string property_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTopEdgeFormattingPropertySource'",NULL);
#endif
 {
  self->setTopEdgeFormattingPropertySource(property_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTopEdgeFormattingPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBottomEdgeFormattingPropertySource of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setBottomEdgeFormattingPropertySource00
static int tolua_CEGUI_CEGUI_FrameComponent_setBottomEdgeFormattingPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isutf8string(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);
  utf8string property_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBottomEdgeFormattingPropertySource'",NULL);
#endif
 {
  self->setBottomEdgeFormattingPropertySource(property_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBottomEdgeFormattingPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBackgroundVerticalFormattingPropertySource of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setBackgroundVerticalFormattingPropertySource00
static int tolua_CEGUI_CEGUI_FrameComponent_setBackgroundVerticalFormattingPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isutf8string(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);
  utf8string property_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBackgroundVerticalFormattingPropertySource'",NULL);
#endif
 {
  self->setBackgroundVerticalFormattingPropertySource(property_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBackgroundVerticalFormattingPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBackgroundHorizontalFormattingPropertySource of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setBackgroundHorizontalFormattingPropertySource00
static int tolua_CEGUI_CEGUI_FrameComponent_setBackgroundHorizontalFormattingPropertySource00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::FrameComponent",0,&tolua_err) ||
 !tolua_isutf8string(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);
  utf8string property_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBackgroundHorizontalFormattingPropertySource'",NULL);
#endif
 {
  self->setBackgroundHorizontalFormattingPropertySource(property_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBackgroundHorizontalFormattingPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLeftEdgeFormatting of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_getLeftEdgeFormatting00
static int tolua_CEGUI_CEGUI_FrameComponent_getLeftEdgeFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FrameComponent",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::FrameComponent* self = (const CEGUI::FrameComponent*)  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 'getLeftEdgeFormatting'",NULL);
#endif
 {
  CEGUI::VerticalFormatting tolua_ret = (CEGUI::VerticalFormatting)  self->getLeftEdgeFormatting(*wnd);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLeftEdgeFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRightEdgeFormatting of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_getRightEdgeFormatting00
static int tolua_CEGUI_CEGUI_FrameComponent_getRightEdgeFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FrameComponent",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::FrameComponent* self = (const CEGUI::FrameComponent*)  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 'getRightEdgeFormatting'",NULL);
#endif
 {
  CEGUI::VerticalFormatting tolua_ret = (CEGUI::VerticalFormatting)  self->getRightEdgeFormatting(*wnd);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getRightEdgeFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTopEdgeFormatting of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_getTopEdgeFormatting00
static int tolua_CEGUI_CEGUI_FrameComponent_getTopEdgeFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FrameComponent",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::FrameComponent* self = (const CEGUI::FrameComponent*)  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 'getTopEdgeFormatting'",NULL);
#endif
 {
  CEGUI::HorizontalFormatting tolua_ret = (CEGUI::HorizontalFormatting)  self->getTopEdgeFormatting(*wnd);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTopEdgeFormatting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getBottomEdgeFormatting of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_getBottomEdgeFormatting00
static int tolua_CEGUI_CEGUI_FrameComponent_getBottomEdgeFormatting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::FrameComponent",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::FrameComponent* self = (const CEGUI::FrameComponent*)  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 'getBottomEdgeFormatting'",NULL);
#endif
 {
  CEGUI::HorizontalFormatting tolua_ret = (CEGUI::HorizontalFormatting)  self->getBottomEdgeFormatting(*wnd);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getBottomEdgeFormatting'.",&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_isusertype(tolua_S,2,"const CEGUI::Window",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);
  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 'getBackgroundVerticalFormatting'",NULL);
#endif
 {
  CEGUI::VerticalFormatting tolua_ret = (CEGUI::VerticalFormatting)  self->getBackgroundVerticalFormatting(*wnd);
 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: 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_isusertype(tolua_S,2,"const CEGUI::Window",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);
  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 'getBackgroundHorizontalFormatting'",NULL);
#endif
 {
  CEGUI::HorizontalFormatting tolua_ret = (CEGUI::HorizontalFormatting)  self->getBackgroundHorizontalFormatting(*wnd);
 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: 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_isusertype(tolua_S,3,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,4,&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));
  const CEGUI::Window* wnd = ((const CEGUI::Window*)  tolua_tousertype(tolua_S,3,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,*wnd);
 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_isnoobj(tolua_S,4,&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 name = ((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(part,name);
 }
 }
 return 0;
tolua_lerror:
 return tolua_CEGUI_CEGUI_FrameComponent_setImage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setImagePropertySource of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_setImagePropertySource00
static int tolua_CEGUI_CEGUI_FrameComponent_setImagePropertySource00(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_isutf8string(tolua_S,3,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));
  utf8string name = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setImagePropertySource'",NULL);
#endif
 {
  self->setImagePropertySource(part,name);
 }
 }
 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: isImageSpecified of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_isImageSpecified00
static int tolua_CEGUI_CEGUI_FrameComponent_isImageSpecified00(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 'isImageSpecified'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isImageSpecified(part);
 tolua_pushboolean(tolua_S,(bool)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isImageSpecified'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isImageFetchedFromProperty of class  CEGUI::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_isImageFetchedFromProperty00
static int tolua_CEGUI_CEGUI_FrameComponent_isImageFetchedFromProperty00(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 'isImageFetchedFromProperty'",NULL);
#endif
 {
  bool tolua_ret = (bool)  self->isImageFetchedFromProperty(part);
 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::FrameComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_FrameComponent_getImagePropertySource00
static int tolua_CEGUI_CEGUI_FrameComponent_getImagePropertySource00(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 'getImagePropertySource'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getImagePropertySource(part);
 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: 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_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
 {
  CEGUI::ImageryComponent* self = (CEGUI::ImageryComponent*)  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 'setImage'",NULL);
#endif
 {
  self->setImage(name);
 }
 }
 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_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageryComponent* self = (const CEGUI::ImageryComponent*)  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 'getVerticalFormatting'",NULL);
#endif
 {
  CEGUI::VerticalFormatting tolua_ret = (CEGUI::VerticalFormatting)  self->getVerticalFormatting(*wnd);
 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_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::ImageryComponent* self = (const CEGUI::ImageryComponent*)  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 'getHorizontalFormatting'",NULL);
#endif
 {
  CEGUI::HorizontalFormatting tolua_ret = (CEGUI::HorizontalFormatting)  self->getHorizontalFormatting(*wnd);
 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: setHorizontalFormattingPropertySource of class  CEGUI::ImageryComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageryComponent_setHorizontalFormattingPropertySource00
static int tolua_CEGUI_CEGUI_ImageryComponent_setHorizontalFormattingPropertySource00(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_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHorizontalFormattingPropertySource'",NULL);
#endif
 {
  self->setHorizontalFormattingPropertySource(property_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHorizontalFormattingPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVerticalFormattingPropertySource of class  CEGUI::ImageryComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_ImageryComponent_setVerticalFormattingPropertySource00
static int tolua_CEGUI_CEGUI_ImageryComponent_setVerticalFormattingPropertySource00(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_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVerticalFormattingPropertySource'",NULL);
#endif
 {
  self->setVerticalFormattingPropertySource(property_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVerticalFormattingPropertySource'.",&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: getEffectiveText of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_getEffectiveText00
static int tolua_CEGUI_CEGUI_TextComponent_getEffectiveText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TextComponent",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::TextComponent* self = (const CEGUI::TextComponent*)  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 'getEffectiveText'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getEffectiveText(*wnd);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEffectiveText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTextVisual of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_getTextVisual00
static int tolua_CEGUI_CEGUI_TextComponent_getTextVisual00(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 'getTextVisual'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getTextVisual();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTextVisual'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEffectiveVisualText of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_getEffectiveVisualText00
static int tolua_CEGUI_CEGUI_TextComponent_getEffectiveVisualText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TextComponent",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::TextComponent* self = (const CEGUI::TextComponent*)  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 'getEffectiveVisualText'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getEffectiveVisualText(*wnd);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEffectiveVisualText'.",&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: getEffectiveFont of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_getEffectiveFont00
static int tolua_CEGUI_CEGUI_TextComponent_getEffectiveFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TextComponent",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::TextComponent* self = (const CEGUI::TextComponent*)  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 'getEffectiveFont'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getEffectiveFont(*wnd);
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEffectiveFont'.",&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_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TextComponent* self = (const CEGUI::TextComponent*)  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 'getVerticalFormatting'",NULL);
#endif
 {
  CEGUI::VerticalTextFormatting tolua_ret = (CEGUI::VerticalTextFormatting)  self->getVerticalFormatting(*wnd);
 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_isusertype(tolua_S,2,"const CEGUI::Window",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  const CEGUI::TextComponent* self = (const CEGUI::TextComponent*)  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 'getHorizontalFormatting'",NULL);
#endif
 {
  CEGUI::HorizontalTextFormatting tolua_ret = (CEGUI::HorizontalTextFormatting)  self->getHorizontalFormatting(*wnd);
 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: setHorizontalFormattingPropertySource of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_setHorizontalFormattingPropertySource00
static int tolua_CEGUI_CEGUI_TextComponent_setHorizontalFormattingPropertySource00(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_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setHorizontalFormattingPropertySource'",NULL);
#endif
 {
  self->setHorizontalFormattingPropertySource(property_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setHorizontalFormattingPropertySource'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setVerticalFormattingPropertySource of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_setVerticalFormattingPropertySource00
static int tolua_CEGUI_CEGUI_TextComponent_setVerticalFormattingPropertySource00(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_name = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setVerticalFormattingPropertySource'",NULL);
#endif
 {
  self->setVerticalFormattingPropertySource(property_name);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setVerticalFormattingPropertySource'.",&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: getHorizontalTextExtent of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_getHorizontalTextExtent00
static int tolua_CEGUI_CEGUI_TextComponent_getHorizontalTextExtent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TextComponent",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::TextComponent* self = (const CEGUI::TextComponent*)  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 'getHorizontalTextExtent'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getHorizontalTextExtent(*window);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHorizontalTextExtent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getVerticalTextExtent of class  CEGUI::TextComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_TextComponent_getVerticalTextExtent00
static int tolua_CEGUI_CEGUI_TextComponent_getVerticalTextExtent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"const CEGUI::TextComponent",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::TextComponent* self = (const CEGUI::TextComponent*)  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 'getVerticalTextExtent'",NULL);
#endif
 {
  float tolua_ret = (float)  self->getVerticalTextExtent(*window);
 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getVerticalTextExtent'.",&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<float>",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<float>* clipper = ((const CEGUI::Rect<float>*)  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<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::Rect<float>",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<float>* baseRect = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::ColourRect* modColours = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Rect<float>* clipper = ((const CEGUI::Rect<float>*)  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: 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<float> tolua_ret = (CEGUI::Rect<float>)  self->getBoundingRect(*wnd);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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<float>",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<float>* rect = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getBoundingRect'",NULL);
#endif
 {
  CEGUI::Rect<float> tolua_ret = (CEGUI::Rect<float>)  self->getBoundingRect(*wnd,*rect);
 {
#ifdef __cplusplus
 void* tolua_obj = new CEGUI::Rect<float>(tolua_ret);
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#else
 void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(CEGUI::Rect<float>));
 tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"CEGUI::Rect<float>");
#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<float>",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<float>* clipper = ((const CEGUI::Rect<float>*)  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<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::Rect<float>",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<float>* baseRect = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::ColourRect* modcols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Rect<float>* clipper = ((const CEGUI::Rect<float>*)  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: 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<float>",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<float>* clipper = ((const CEGUI::Rect<float>*)  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<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::Rect<float>",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<float>* baseRect = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::ColourRect* modcols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Rect<float>* clipper = ((const CEGUI::Rect<float>*)  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<float>",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<float>* clipper = ((const CEGUI::Rect<float>*)  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<float>",0,&tolua_err) ||
 !tolua_isusertype(tolua_S,4,"const CEGUI::ColourRect",1,&tolua_err) ||
 !tolua_isusertype(tolua_S,5,"const CEGUI::Rect<float>",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<float>* baseRect = ((const CEGUI::Rect<float>*)  tolua_tousertype(tolua_S,3,0));
  const CEGUI::ColourRect* modcols = ((const CEGUI::ColourRect*)  tolua_tousertype(tolua_S,4,0));
  const CEGUI::Rect<float>* clipper = ((const CEGUI::Rect<float>*)  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: getWidgetName of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_getWidgetName00
static int tolua_CEGUI_CEGUI_WidgetComponent_getWidgetName00(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 'getWidgetName'",NULL);
#endif
 {
  string tolua_ret = (string)  self->getWidgetName();
 tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
 }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getWidgetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setWidgetName of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_setWidgetName00
static int tolua_CEGUI_CEGUI_WidgetComponent_setWidgetName00(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 'setWidgetName'",NULL);
#endif
 {
  self->setWidgetName(suffix);
 }
 }
 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: 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: setAutoWindow of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_setAutoWindow00
static int tolua_CEGUI_CEGUI_WidgetComponent_setAutoWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetComponent",0,&tolua_err) ||
 !tolua_isboolean(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);
  bool is_auto = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoWindow'",NULL);
#endif
 {
  self->setAutoWindow(is_auto);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAutoWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isAutoWindow of class  CEGUI::WidgetComponent */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetComponent_isAutoWindow00
static int tolua_CEGUI_CEGUI_WidgetComponent_isAutoWindow00(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 '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: 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_isboolean(tolua_S,6,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,7,&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));
  bool autoWindow = ((bool)  tolua_toboolean(tolua_S,6,0));
 {
  CEGUI::WidgetComponent* tolua_ret = (CEGUI::WidgetComponent*)  new CEGUI::WidgetComponent(type,look,suffix,renderer,autoWindow);
 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_isboolean(tolua_S,6,0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,7,&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));
  bool autoWindow = ((bool)  tolua_toboolean(tolua_S,6,0));
 {
  CEGUI::WidgetComponent* tolua_ret = (CEGUI::WidgetComponent*)  new CEGUI::WidgetComponent(type,look,suffix,renderer,autoWindow);
 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: 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: 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_isutf8string(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));
  utf8string inherits = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
 {
  CEGUI::WidgetLookFeel* tolua_ret = (CEGUI::WidgetLookFeel*)  new CEGUI::WidgetLookFeel(name,inherits);
 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_isutf8string(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));
  utf8string inherits = ((utf8string)  tolua_toutf8string(tolua_S,3,0));
 {
  CEGUI::WidgetLookFeel* tolua_ret = (CEGUI::WidgetLookFeel*)  new CEGUI::WidgetLookFeel(name,inherits);
 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: parseLookNFeelSpecificationFromFile of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_parseLookNFeelSpecificationFromFile00
static int tolua_CEGUI_CEGUI_WidgetLookManager_parseLookNFeelSpecificationFromFile00(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 'parseLookNFeelSpecificationFromFile'",NULL);
#endif
 {
  self->parseLookNFeelSpecificationFromFile(filename,resourceGroup);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'parseLookNFeelSpecificationFromFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: parseLookNFeelSpecificationFromString of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_parseLookNFeelSpecificationFromString00
static int tolua_CEGUI_CEGUI_WidgetLookManager_parseLookNFeelSpecificationFromString00(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 source = ((utf8string)  tolua_toutf8string(tolua_S,2,0));
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'parseLookNFeelSpecificationFromString'",NULL);
#endif
 {
  self->parseLookNFeelSpecificationFromString(source);
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'parseLookNFeelSpecificationFromString'.",&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: eraseAllWidgetLooks of class  CEGUI::WidgetLookManager */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_WidgetLookManager_eraseAllWidgetLooks00
static int tolua_CEGUI_CEGUI_WidgetLookManager_eraseAllWidgetLooks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
 !tolua_isusertype(tolua_S,1,"CEGUI::WidgetLookManager",0,&tolua_err) ||
 !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
 goto tolua_lerror;
 else
#endif
 {
  CEGUI::WidgetLookManager* self = (CEGUI::WidgetLookManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
 if (!self) tolua_error(tolua_S,"invalid 'self' in function 'eraseAllWidgetLooks'",NULL);
#endif
 {
  self->eraseAllWidgetLooks();
 }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'eraseAllWidgetLooks'.",&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,"AM_IGNORE",CEGUI::AM_IGNORE);
  tolua_constant(tolua_S,"AM_SHRINK",CEGUI::AM_SHRINK);
  tolua_constant(tolua_S,"AM_EXPAND",CEGUI::AM_EXPAND);
  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,"Vector2f","CEGUI::Vector2<float>","",tolua_collect_CEGUI__Vector2_float_);
  #else
  tolua_cclass(tolua_S,"Vector2f","CEGUI::Vector2<float>","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Vector2f");
   tolua_variable(tolua_S,"x",tolua_get_CEGUI__Vector2_float__x,tolua_set_CEGUI__Vector2_float__x);
   tolua_variable(tolua_S,"y",tolua_get_CEGUI__Vector2_float__y,tolua_set_CEGUI__Vector2_float__y);
   tolua_function(tolua_S,".add",tolua_CEGUI_CEGUI_Vector2f__add00);
   tolua_function(tolua_S,".sub",tolua_CEGUI_CEGUI_Vector2f__sub00);
   tolua_function(tolua_S,".mul",tolua_CEGUI_CEGUI_Vector2f__mul00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_Vector2f__eq00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Vector2f_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Vector2f_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Vector2f_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Vector2f_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Vector2f_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Vector2f_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Vector3f","CEGUI::Vector3<float>","",tolua_collect_CEGUI__Vector3_float_);
  #else
  tolua_cclass(tolua_S,"Vector3f","CEGUI::Vector3<float>","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Vector3f");
   tolua_variable(tolua_S,"x",tolua_get_CEGUI__Vector3_float__x,tolua_set_CEGUI__Vector3_float__x);
   tolua_variable(tolua_S,"y",tolua_get_CEGUI__Vector3_float__y,tolua_set_CEGUI__Vector3_float__y);
   tolua_variable(tolua_S,"z",tolua_get_CEGUI__Vector3_float__z,tolua_set_CEGUI__Vector3_float__z);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_Vector3f__eq00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Vector3f_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Vector3f_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Vector3f_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Vector3f_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Vector3f_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Vector3f_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Sizef","CEGUI::Size<float>","",tolua_collect_CEGUI__Size_float_);
  #else
  tolua_cclass(tolua_S,"Sizef","CEGUI::Size<float>","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Sizef");
   tolua_variable(tolua_S,"width",tolua_get_CEGUI__Size_float__width,tolua_set_CEGUI__Size_float__width);
   tolua_variable(tolua_S,"height",tolua_get_CEGUI__Size_float__height,tolua_set_CEGUI__Size_float__height);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_Sizef__eq00);
   tolua_function(tolua_S,"clamp",tolua_CEGUI_CEGUI_Sizef_clamp00);
   tolua_function(tolua_S,"scaleToAspect",tolua_CEGUI_CEGUI_Sizef_scaleToAspect00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Sizef_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Sizef_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Sizef_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Sizef_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Sizef_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Sizef_new01_local);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Rectf","CEGUI::Rect<float>","",tolua_collect_CEGUI__Rect_float_);
  #else
  tolua_cclass(tolua_S,"Rectf","CEGUI::Rect<float>","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Rectf");
   tolua_variable(tolua_S,"min",tolua_get_CEGUI__Rect_float__min,tolua_set_CEGUI__Rect_float__min);
   tolua_variable(tolua_S,"max",tolua_get_CEGUI__Rect_float__max,tolua_set_CEGUI__Rect_float__max);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Rectf_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Rectf_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Rectf_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Rectf_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Rectf_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Rectf_new01_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Rectf_new02);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Rectf_new02_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Rectf_new02_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Rectf_new03);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Rectf_new03_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Rectf_new03_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Rectf_new04);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Rectf_new04_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Rectf_new04_local);
   tolua_function(tolua_S,"left",tolua_CEGUI_CEGUI_Rectf_left00);
   tolua_function(tolua_S,"top",tolua_CEGUI_CEGUI_Rectf_top00);
   tolua_function(tolua_S,"right",tolua_CEGUI_CEGUI_Rectf_right00);
   tolua_function(tolua_S,"bottom",tolua_CEGUI_CEGUI_Rectf_bottom00);
   tolua_function(tolua_S,"left",tolua_CEGUI_CEGUI_Rectf_left01);
   tolua_function(tolua_S,"top",tolua_CEGUI_CEGUI_Rectf_top01);
   tolua_function(tolua_S,"right",tolua_CEGUI_CEGUI_Rectf_right01);
   tolua_function(tolua_S,"bottom",tolua_CEGUI_CEGUI_Rectf_bottom01);
   tolua_function(tolua_S,"setPosition",tolua_CEGUI_CEGUI_Rectf_setPosition00);
   tolua_function(tolua_S,"getPosition",tolua_CEGUI_CEGUI_Rectf_getPosition00);
   tolua_function(tolua_S,"setSize",tolua_CEGUI_CEGUI_Rectf_setSize00);
   tolua_function(tolua_S,"getSize",tolua_CEGUI_CEGUI_Rectf_getSize00);
   tolua_function(tolua_S,"setWidth",tolua_CEGUI_CEGUI_Rectf_setWidth00);
   tolua_function(tolua_S,"getWidth",tolua_CEGUI_CEGUI_Rectf_getWidth00);
   tolua_function(tolua_S,"setHeight",tolua_CEGUI_CEGUI_Rectf_setHeight00);
   tolua_function(tolua_S,"getHeight",tolua_CEGUI_CEGUI_Rectf_getHeight00);
   tolua_function(tolua_S,"getIntersection",tolua_CEGUI_CEGUI_Rectf_getIntersection00);
   tolua_function(tolua_S,"offset",tolua_CEGUI_CEGUI_Rectf_offset00);
   tolua_function(tolua_S,"isPointInRect",tolua_CEGUI_CEGUI_Rectf_isPointInRect00);
   tolua_function(tolua_S,"constrainSizeMax",tolua_CEGUI_CEGUI_Rectf_constrainSizeMax00);
   tolua_function(tolua_S,"constrainSizeMin",tolua_CEGUI_CEGUI_Rectf_constrainSizeMin00);
   tolua_function(tolua_S,"constrainSize",tolua_CEGUI_CEGUI_Rectf_constrainSize00);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_Rectf__eq00);
   tolua_function(tolua_S,".mul",tolua_CEGUI_CEGUI_Rectf__mul00);
   tolua_function(tolua_S,".add",tolua_CEGUI_CEGUI_Rectf__add00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Quaternion","CEGUI::Quaternion","",tolua_collect_CEGUI__Quaternion);
  #else
  tolua_cclass(tolua_S,"Quaternion","CEGUI::Quaternion","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Quaternion");
   tolua_variable(tolua_S,"w",tolua_get_CEGUI__Quaternion_w,tolua_set_CEGUI__Quaternion_w);
   tolua_variable(tolua_S,"x",tolua_get_CEGUI__Quaternion_x,tolua_set_CEGUI__Quaternion_x);
   tolua_variable(tolua_S,"y",tolua_get_CEGUI__Quaternion_y,tolua_set_CEGUI__Quaternion_y);
   tolua_variable(tolua_S,"z",tolua_get_CEGUI__Quaternion_z,tolua_set_CEGUI__Quaternion_z);
   tolua_variable(tolua_S,"ZERO",tolua_get_CEGUI__Quaternion_ZERO,NULL);
   tolua_variable(tolua_S,"IDENTITY",tolua_get_CEGUI__Quaternion_IDENTITY,NULL);
   tolua_function(tolua_S,"eulerAnglesRadians",tolua_CEGUI_CEGUI_Quaternion_eulerAnglesRadians00);
   tolua_function(tolua_S,"eulerAnglesDegrees",tolua_CEGUI_CEGUI_Quaternion_eulerAnglesDegrees00);
   tolua_function(tolua_S,"axisAngleRadians",tolua_CEGUI_CEGUI_Quaternion_axisAngleRadians00);
   tolua_function(tolua_S,"axisAngleDegrees",tolua_CEGUI_CEGUI_Quaternion_axisAngleDegrees00);
   tolua_function(tolua_S,"slerp",tolua_CEGUI_CEGUI_Quaternion_slerp00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Quaternion_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Quaternion_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Quaternion_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Quaternion_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Quaternion_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Quaternion_new01_local);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_Quaternion__eq00);
   tolua_function(tolua_S,".sub",tolua_CEGUI_CEGUI_Quaternion__sub00);
   tolua_function(tolua_S,".add",tolua_CEGUI_CEGUI_Quaternion__add00);
   tolua_function(tolua_S,".mul",tolua_CEGUI_CEGUI_Quaternion__mul00);
   tolua_function(tolua_S,".mul",tolua_CEGUI_CEGUI_Quaternion__mul01);
   tolua_function(tolua_S,"dot",tolua_CEGUI_CEGUI_Quaternion_dot00);
   tolua_function(tolua_S,"length",tolua_CEGUI_CEGUI_Quaternion_length00);
   tolua_function(tolua_S,"normalise",tolua_CEGUI_CEGUI_Quaternion_normalise00);
  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,".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,".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,"USize","CEGUI::USize","",tolua_collect_CEGUI__USize);
  #else
  tolua_cclass(tolua_S,"USize","CEGUI::USize","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"USize");
   tolua_variable(tolua_S,"width",tolua_get_CEGUI__USize_width,tolua_set_CEGUI__USize_width);
   tolua_variable(tolua_S,"height",tolua_get_CEGUI__USize_height,tolua_set_CEGUI__USize_height);
   tolua_function(tolua_S,".eq",tolua_CEGUI_CEGUI_USize__eq00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_USize_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_USize_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_USize_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_USize_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_USize_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_USize_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,"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,"notifyDisplaySizeChanged",tolua_CEGUI_CEGUI_Font_notifyDisplaySizeChanged00);
   tolua_function(tolua_S,"setNativeResolution",tolua_CEGUI_CEGUI_Font_setNativeResolution00);
   tolua_function(tolua_S,"setAutoScaled",tolua_CEGUI_CEGUI_Font_setAutoScaled00);
   tolua_function(tolua_S,"getAutoScaled",tolua_CEGUI_CEGUI_Font_getAutoScaled00);
   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,"createFromFile",tolua_CEGUI_CEGUI_FontManager_createFromFile00);
   tolua_function(tolua_S,"createFromString",tolua_CEGUI_CEGUI_FontManager_createFromString00);
   tolua_function(tolua_S,"createFreeTypeFont",tolua_CEGUI_CEGUI_FontManager_createFreeTypeFont00);
   tolua_function(tolua_S,"createFreeTypeFont",tolua_CEGUI_CEGUI_FontManager_createFreeTypeFont01);
   tolua_function(tolua_S,"createPixmapFont",tolua_CEGUI_CEGUI_FontManager_createPixmapFont00);
   tolua_function(tolua_S,"createPixmapFont",tolua_CEGUI_CEGUI_FontManager_createPixmapFont01);
   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);
  tolua_constant(tolua_S,"ASM_Disabled",CEGUI::ASM_Disabled);
  tolua_constant(tolua_S,"ASM_Vertical",CEGUI::ASM_Vertical);
  tolua_constant(tolua_S,"ASM_Horizontal",CEGUI::ASM_Horizontal);
  tolua_constant(tolua_S,"ASM_Min",CEGUI::ASM_Min);
  tolua_constant(tolua_S,"ASM_Max",CEGUI::ASM_Max);
  tolua_constant(tolua_S,"ASM_Both",CEGUI::ASM_Both);
  tolua_cclass(tolua_S,"Image","CEGUI::Image","",NULL);
  tolua_beginmodule(tolua_S,"Image");
   tolua_function(tolua_S,"getName",tolua_CEGUI_CEGUI_Image_getName00);
   tolua_function(tolua_S,"getRenderedSize",tolua_CEGUI_CEGUI_Image_getRenderedSize00);
   tolua_function(tolua_S,"getRenderedOffset",tolua_CEGUI_CEGUI_Image_getRenderedOffset00);
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_Image_render00);
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_Image_render01);
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_Image_render02);
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_Image_render03);
   tolua_function(tolua_S,"render",tolua_CEGUI_CEGUI_Image_render04);
   tolua_function(tolua_S,"computeScalingFactors",tolua_CEGUI_CEGUI_Image_computeScalingFactors00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"BasicImage","CEGUI::BasicImage","CEGUI::Image",NULL);
  tolua_beginmodule(tolua_S,"BasicImage");
   tolua_function(tolua_S,"setTexture",tolua_CEGUI_CEGUI_BasicImage_setTexture00);
   tolua_function(tolua_S,"setArea",tolua_CEGUI_CEGUI_BasicImage_setArea00);
   tolua_function(tolua_S,"setOffset",tolua_CEGUI_CEGUI_BasicImage_setOffset00);
   tolua_function(tolua_S,"setAutoScaled",tolua_CEGUI_CEGUI_BasicImage_setAutoScaled00);
   tolua_function(tolua_S,"setNativeResolution",tolua_CEGUI_CEGUI_BasicImage_setNativeResolution00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ImageFactory","CEGUI::ImageFactory","",NULL);
  tolua_beginmodule(tolua_S,"ImageFactory");
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"ImagePair","CEGUI::ImagePair","",tolua_collect_CEGUI__ImagePair);
  #else
  tolua_cclass(tolua_S,"ImagePair","CEGUI::ImagePair","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ImagePair");
   tolua_function(tolua_S,"delete",tolua_CEGUI_CEGUI_ImagePair_delete00);
   tolua_variable(tolua_S,"first",tolua_get_CEGUI__ImagePair_first_ptr,tolua_set_CEGUI__ImagePair_first_ptr);
   tolua_variable(tolua_S,"second",tolua_get_CEGUI__ImagePair_second_ptr,tolua_set_CEGUI__ImagePair_second_ptr);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"ImageManager","CEGUI::ImageManager","",NULL);
  tolua_beginmodule(tolua_S,"ImageManager");
   tolua_function(tolua_S,"getSingleton",tolua_CEGUI_CEGUI_ImageManager_getSingleton00);
   tolua_function(tolua_S,"removeImageType",tolua_CEGUI_CEGUI_ImageManager_removeImageType00);
   tolua_function(tolua_S,"isImageTypeAvailable",tolua_CEGUI_CEGUI_ImageManager_isImageTypeAvailable00);
   tolua_function(tolua_S,"create",tolua_CEGUI_CEGUI_ImageManager_create00);
   tolua_function(tolua_S,"destroy",tolua_CEGUI_CEGUI_ImageManager_destroy00);
   tolua_function(tolua_S,"destroy",tolua_CEGUI_CEGUI_ImageManager_destroy01);
   tolua_function(tolua_S,"destroyAll",tolua_CEGUI_CEGUI_ImageManager_destroyAll00);
   tolua_function(tolua_S,"get",tolua_CEGUI_CEGUI_ImageManager_get00);
   tolua_function(tolua_S,"isDefined",tolua_CEGUI_CEGUI_ImageManager_isDefined00);
   tolua_function(tolua_S,"getImageCount",tolua_CEGUI_CEGUI_ImageManager_getImageCount00);
   tolua_function(tolua_S,"loadImageset",tolua_CEGUI_CEGUI_ImageManager_loadImageset00);
   tolua_function(tolua_S,"destroyImageCollection",tolua_CEGUI_CEGUI_ImageManager_destroyImageCollection00);
   tolua_function(tolua_S,"addFromImageFile",tolua_CEGUI_CEGUI_ImageManager_addFromImageFile00);
   tolua_function(tolua_S,"notifyDisplaySizeChanged",tolua_CEGUI_CEGUI_ImageManager_notifyDisplaySizeChanged00);
   tolua_function(tolua_S,"setImagesetDefaultResourceGroup",tolua_CEGUI_CEGUI_ImageManager_setImagesetDefaultResourceGroup00);
   tolua_function(tolua_S,"getImagesetDefaultResourceGroup",tolua_CEGUI_CEGUI_ImageManager_getImagesetDefaultResourceGroup00);
   tolua_function(tolua_S,"getIterator",tolua_CEGUI_CEGUI_ImageManager_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 1");
   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 2");
   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 3");
   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,"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 4");
   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 5");
   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 6");
   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 7");
   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 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,"SimpleTimer","CEGUI::SimpleTimer","",tolua_collect_CEGUI__SimpleTimer);
  #else
  tolua_cclass(tolua_S,"SimpleTimer","CEGUI::SimpleTimer","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"SimpleTimer");
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_SimpleTimer_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_SimpleTimer_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_SimpleTimer_new00_local);
   tolua_function(tolua_S,"currentTime",tolua_CEGUI_CEGUI_SimpleTimer_currentTime00);
   tolua_function(tolua_S,"restart",tolua_CEGUI_CEGUI_SimpleTimer_restart00);
   tolua_function(tolua_S,"elapsed",tolua_CEGUI_CEGUI_SimpleTimer_elapsed00);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Key",0);
  tolua_beginmodule(tolua_S,"Key");
   tolua_constant(tolua_S,"Unknown",CEGUI::Key::Unknown);
   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_cclass(tolua_S,"SystemKeys","CEGUI::SystemKeys","",NULL);
  tolua_beginmodule(tolua_S,"SystemKeys");
   tolua_constant(tolua_S,"None",CEGUI::SystemKeys::None);
   tolua_constant(tolua_S,"LeftMouse",CEGUI::SystemKeys::LeftMouse);
   tolua_constant(tolua_S,"RightMouse",CEGUI::SystemKeys::RightMouse);
   tolua_constant(tolua_S,"Shift",CEGUI::SystemKeys::Shift);
   tolua_constant(tolua_S,"Control",CEGUI::SystemKeys::Control);
   tolua_constant(tolua_S,"MiddleMouse",CEGUI::SystemKeys::MiddleMouse);
   tolua_constant(tolua_S,"X1Mouse",CEGUI::SystemKeys::X1Mouse);
   tolua_constant(tolua_S,"X2Mouse",CEGUI::SystemKeys::X2Mouse);
   tolua_constant(tolua_S,"Alt",CEGUI::SystemKeys::Alt);
   tolua_function(tolua_S,"reset",tolua_CEGUI_CEGUI_SystemKeys_reset00);
   tolua_function(tolua_S,"get",tolua_CEGUI_CEGUI_SystemKeys_get00);
   tolua_function(tolua_S,"isPressed",tolua_CEGUI_CEGUI_SystemKeys_isPressed00);
   tolua_function(tolua_S,"keyPressed",tolua_CEGUI_CEGUI_SystemKeys_keyPressed00);
   tolua_function(tolua_S,"keyReleased",tolua_CEGUI_CEGUI_SystemKeys_keyReleased00);
   tolua_function(tolua_S,"mouseButtonPressed",tolua_CEGUI_CEGUI_SystemKeys_mouseButtonPressed00);
   tolua_function(tolua_S,"mouseButtonReleased",tolua_CEGUI_CEGUI_SystemKeys_mouseButtonReleased00);
   tolua_function(tolua_S,"mouseButtonToSystemKey",tolua_CEGUI_CEGUI_SystemKeys_mouseButtonToSystemKey00);
   tolua_function(tolua_S,"keyCodeToSystemKey",tolua_CEGUI_CEGUI_SystemKeys_keyCodeToSystemKey00);
  tolua_endmodule(tolua_S);
  #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_cclass(tolua_S,"MouseCursor","CEGUI::MouseCursor","CEGUI::EventSet",NULL);
  tolua_beginmodule(tolua_S,"MouseCursor");
   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,"setDefaultImage",tolua_CEGUI_CEGUI_MouseCursor_setDefaultImage00);
   tolua_function(tolua_S,"setDefaultImage",tolua_CEGUI_CEGUI_MouseCursor_setDefaultImage01);
   tolua_function(tolua_S,"getDefaultImage",tolua_CEGUI_CEGUI_MouseCursor_getDefaultImage00);
   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,"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,"VA_TOP",CEGUI::VA_TOP);
  tolua_constant(tolua_S,"VA_CENTRE",CEGUI::VA_CENTRE);
  tolua_constant(tolua_S,"VA_BOTTOM",CEGUI::VA_BOTTOM);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"ElementEventArgs","CEGUI::ElementEventArgs","CEGUI::EventArgs",tolua_collect_CEGUI__ElementEventArgs);
  #else
  tolua_cclass(tolua_S,"ElementEventArgs","CEGUI::ElementEventArgs","CEGUI::EventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ElementEventArgs");
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_ElementEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_ElementEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_ElementEventArgs_new00_local);
   tolua_variable(tolua_S,"element",tolua_get_CEGUI__ElementEventArgs_element_ptr,tolua_set_CEGUI__ElementEventArgs_element_ptr);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Element","CEGUI::Element","",tolua_collect_CEGUI__Element);
  #else
  tolua_cclass(tolua_S,"Element","CEGUI::Element","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Element");
   tolua_cclass(tolua_S,"CachedRectf","CEGUI::Element::CachedRectf","",NULL);
   tolua_beginmodule(tolua_S,"CachedRectf");
    tolua_function(tolua_S,"get",tolua_CEGUI_CEGUI_Element_CachedRectf_get00);
    tolua_function(tolua_S,"getFresh",tolua_CEGUI_CEGUI_Element_CachedRectf_getFresh00);
    tolua_function(tolua_S,"invalidateCache",tolua_CEGUI_CEGUI_Element_CachedRectf_invalidateCache00);
    tolua_function(tolua_S,"isCacheValid",tolua_CEGUI_CEGUI_Element_CachedRectf_isCacheValid00);
    tolua_function(tolua_S,"regenerateCache",tolua_CEGUI_CEGUI_Element_CachedRectf_regenerateCache00);
   tolua_endmodule(tolua_S);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_Element_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_Element_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_Element_new00_local);
   tolua_function(tolua_S,"delete",tolua_CEGUI_CEGUI_Element_delete00);
   tolua_function(tolua_S,"getParentElement",tolua_CEGUI_CEGUI_Element_getParentElement00);
   tolua_function(tolua_S,"setArea",tolua_CEGUI_CEGUI_Element_setArea00);
   tolua_function(tolua_S,"setArea",tolua_CEGUI_CEGUI_Element_setArea01);
   tolua_function(tolua_S,"setArea",tolua_CEGUI_CEGUI_Element_setArea02);
   tolua_function(tolua_S,"getArea",tolua_CEGUI_CEGUI_Element_getArea00);
   tolua_function(tolua_S,"setPosition",tolua_CEGUI_CEGUI_Element_setPosition00);
   tolua_function(tolua_S,"setXPosition",tolua_CEGUI_CEGUI_Element_setXPosition00);
   tolua_function(tolua_S,"setYPosition",tolua_CEGUI_CEGUI_Element_setYPosition00);
   tolua_function(tolua_S,"getPosition",tolua_CEGUI_CEGUI_Element_getPosition00);
   tolua_function(tolua_S,"getXPosition",tolua_CEGUI_CEGUI_Element_getXPosition00);
   tolua_function(tolua_S,"getYPosition",tolua_CEGUI_CEGUI_Element_getYPosition00);
   tolua_function(tolua_S,"setHorizontalAlignment",tolua_CEGUI_CEGUI_Element_setHorizontalAlignment00);
   tolua_function(tolua_S,"getHorizontalAlignment",tolua_CEGUI_CEGUI_Element_getHorizontalAlignment00);
   tolua_function(tolua_S,"setVerticalAlignment",tolua_CEGUI_CEGUI_Element_setVerticalAlignment00);
   tolua_function(tolua_S,"getVerticalAlignment",tolua_CEGUI_CEGUI_Element_getVerticalAlignment00);
   tolua_function(tolua_S,"setSize",tolua_CEGUI_CEGUI_Element_setSize00);
   tolua_function(tolua_S,"getSize",tolua_CEGUI_CEGUI_Element_getSize00);
   tolua_function(tolua_S,"setWidth",tolua_CEGUI_CEGUI_Element_setWidth00);
   tolua_function(tolua_S,"getWidth",tolua_CEGUI_CEGUI_Element_getWidth00);
   tolua_function(tolua_S,"setHeight",tolua_CEGUI_CEGUI_Element_setHeight00);
   tolua_function(tolua_S,"getHeight",tolua_CEGUI_CEGUI_Element_getHeight00);
   tolua_function(tolua_S,"setMinSize",tolua_CEGUI_CEGUI_Element_setMinSize00);
   tolua_function(tolua_S,"getMinSize",tolua_CEGUI_CEGUI_Element_getMinSize00);
   tolua_function(tolua_S,"setMaxSize",tolua_CEGUI_CEGUI_Element_setMaxSize00);
   tolua_function(tolua_S,"getMaxSize",tolua_CEGUI_CEGUI_Element_getMaxSize00);
   tolua_function(tolua_S,"setAspectMode",tolua_CEGUI_CEGUI_Element_setAspectMode00);
   tolua_function(tolua_S,"getAspectMode",tolua_CEGUI_CEGUI_Element_getAspectMode00);
   tolua_function(tolua_S,"setAspectRatio",tolua_CEGUI_CEGUI_Element_setAspectRatio00);
   tolua_function(tolua_S,"getAspectRatio",tolua_CEGUI_CEGUI_Element_getAspectRatio00);
   tolua_function(tolua_S,"setPixelAligned",tolua_CEGUI_CEGUI_Element_setPixelAligned00);
   tolua_function(tolua_S,"isPixelAligned",tolua_CEGUI_CEGUI_Element_isPixelAligned00);
   tolua_function(tolua_S,"getPixelPosition",tolua_CEGUI_CEGUI_Element_getPixelPosition00);
   tolua_function(tolua_S,"getPixelSize",tolua_CEGUI_CEGUI_Element_getPixelSize00);
   tolua_function(tolua_S,"calculatePixelSize",tolua_CEGUI_CEGUI_Element_calculatePixelSize00);
   tolua_function(tolua_S,"getParentPixelSize",tolua_CEGUI_CEGUI_Element_getParentPixelSize00);
   tolua_function(tolua_S,"getRotation",tolua_CEGUI_CEGUI_Element_getRotation00);
   tolua_function(tolua_S,"addChild",tolua_CEGUI_CEGUI_Element_addChild00);
   tolua_function(tolua_S,"removeChild",tolua_CEGUI_CEGUI_Element_removeChild00);
   tolua_function(tolua_S,"getChildElementAtIdx",tolua_CEGUI_CEGUI_Element_getChildElementAtIdx00);
   tolua_function(tolua_S,"getChildCount",tolua_CEGUI_CEGUI_Element_getChildCount00);
   tolua_function(tolua_S,"isChild",tolua_CEGUI_CEGUI_Element_isChild00);
   tolua_function(tolua_S,"isAncestor",tolua_CEGUI_CEGUI_Element_isAncestor00);
   tolua_function(tolua_S,"setNonClient",tolua_CEGUI_CEGUI_Element_setNonClient00);
   tolua_function(tolua_S,"isNonClient",tolua_CEGUI_CEGUI_Element_isNonClient00);
   tolua_function(tolua_S,"getUnclippedOuterRect",tolua_CEGUI_CEGUI_Element_getUnclippedOuterRect00);
   tolua_function(tolua_S,"getUnclippedInnerRect",tolua_CEGUI_CEGUI_Element_getUnclippedInnerRect00);
   tolua_function(tolua_S,"getUnclippedRect",tolua_CEGUI_CEGUI_Element_getUnclippedRect00);
   tolua_function(tolua_S,"getClientChildContentArea",tolua_CEGUI_CEGUI_Element_getClientChildContentArea00);
   tolua_function(tolua_S,"getNonClientChildContentArea",tolua_CEGUI_CEGUI_Element_getNonClientChildContentArea00);
   tolua_function(tolua_S,"getChildContentArea",tolua_CEGUI_CEGUI_Element_getChildContentArea00);
   tolua_function(tolua_S,"notifyScreenAreaChanged",tolua_CEGUI_CEGUI_Element_notifyScreenAreaChanged00);
   tolua_function(tolua_S,"getRootContainerSize",tolua_CEGUI_CEGUI_Element_getRootContainerSize00);
   tolua_function(tolua_S,"setProperty",tolua_CEGUI_CEGUI_Element_setProperty00);
   tolua_function(tolua_S,"getProperty",tolua_CEGUI_CEGUI_Element_getProperty00);
   tolua_function(tolua_S,"getPropertyDefault",tolua_CEGUI_CEGUI_Element_getPropertyDefault00);
   tolua_function(tolua_S,"getPropertyHelp",tolua_CEGUI_CEGUI_Element_getPropertyHelp00);
   tolua_function(tolua_S,"isPropertyPresent",tolua_CEGUI_CEGUI_Element_isPropertyPresent00);
   tolua_function(tolua_S,"isPropertyDefault",tolua_CEGUI_CEGUI_Element_isPropertyDefault00);
   tolua_function(tolua_S,"getPropertyIterator",tolua_CEGUI_CEGUI_Element_getPropertyIterator00);
   tolua_function(tolua_S,"addEvent",tolua_CEGUI_CEGUI_Element_addEvent00);
   tolua_function(tolua_S,"removeEvent",tolua_CEGUI_CEGUI_Element_removeEvent00);
   tolua_function(tolua_S,"removeAllEvents",tolua_CEGUI_CEGUI_Element_removeAllEvents00);
   tolua_function(tolua_S,"isEventPresent",tolua_CEGUI_CEGUI_Element_isEventPresent00);
   tolua_function(tolua_S,"subscribeEvent",tolua_CEGUI_CEGUI_Element_subscribeEvent00);
   tolua_function(tolua_S,"subscribeEvent",tolua_CEGUI_CEGUI_Element_subscribeEvent01);
   tolua_function(tolua_S,"fireEvent",tolua_CEGUI_CEGUI_Element_fireEvent00);
   tolua_function(tolua_S,"isMuted",tolua_CEGUI_CEGUI_Element_isMuted00);
   tolua_function(tolua_S,"setMutedState",tolua_CEGUI_CEGUI_Element_setMutedState00);
   tolua_function(tolua_S,"getEventIterator",tolua_CEGUI_CEGUI_Element_getEventIterator00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"NamedElementEventArgs","CEGUI::NamedElementEventArgs","CEGUI::EventArgs",tolua_collect_CEGUI__NamedElementEventArgs);
  #else
  tolua_cclass(tolua_S,"NamedElementEventArgs","CEGUI::NamedElementEventArgs","CEGUI::EventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"NamedElementEventArgs");
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_NamedElementEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_NamedElementEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_NamedElementEventArgs_new00_local);
   tolua_variable(tolua_S,"element",tolua_get_CEGUI__NamedElementEventArgs_element_ptr,tolua_set_CEGUI__NamedElementEventArgs_element_ptr);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"NamedElement","CEGUI::NamedElement","CEGUI::Element",tolua_collect_CEGUI__NamedElement);
  #else
  tolua_cclass(tolua_S,"NamedElement","CEGUI::NamedElement","CEGUI::Element",NULL);
  #endif
  tolua_beginmodule(tolua_S,"NamedElement");
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_NamedElement_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_NamedElement_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_NamedElement_new00_local);
   tolua_function(tolua_S,"delete",tolua_CEGUI_CEGUI_NamedElement_delete00);
   tolua_function(tolua_S,"setName",tolua_CEGUI_CEGUI_NamedElement_setName00);
   tolua_function(tolua_S,"getName",tolua_CEGUI_CEGUI_NamedElement_getName00);
   tolua_function(tolua_S,"getNamePath",tolua_CEGUI_CEGUI_NamedElement_getNamePath00);
   tolua_function(tolua_S,"isChild",tolua_CEGUI_CEGUI_NamedElement_isChild00);
   tolua_function(tolua_S,"isAncestor",tolua_CEGUI_CEGUI_NamedElement_isAncestor00);
   tolua_function(tolua_S,"getChildElement",tolua_CEGUI_CEGUI_NamedElement_getChildElement00);
   tolua_function(tolua_S,"removeChild",tolua_CEGUI_CEGUI_NamedElement_removeChild00);
  tolua_endmodule(tolua_S);
  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","CEGUI::NamedElement",NULL);
  tolua_beginmodule(tolua_S,"Window");
   tolua_function(tolua_S,"getType",tolua_CEGUI_CEGUI_Window_getType00);
   tolua_function(tolua_S,"setAutoWindow",tolua_CEGUI_CEGUI_Window_setAutoWindow00);
   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,"isEffectiveDisabled",tolua_CEGUI_CEGUI_Window_isEffectiveDisabled00);
   tolua_function(tolua_S,"isVisible",tolua_CEGUI_CEGUI_Window_isVisible00);
   tolua_function(tolua_S,"isEffectiveVisible",tolua_CEGUI_CEGUI_Window_isEffectiveVisible00);
   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,"setDisabled",tolua_CEGUI_CEGUI_Window_setDisabled00);
   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,"getRootWindow",tolua_CEGUI_CEGUI_Window_getRootWindow00);
   tolua_function(tolua_S,"getRootWindow",tolua_CEGUI_CEGUI_Window_getRootWindow01);
   tolua_function(tolua_S,"getParent",tolua_CEGUI_CEGUI_Window_getParent00);
   tolua_function(tolua_S,"getActiveSibling",tolua_CEGUI_CEGUI_Window_getActiveSibling00);
   tolua_function(tolua_S,"getActiveChild",tolua_CEGUI_CEGUI_Window_getActiveChild00);
   tolua_function(tolua_S,"getActiveChild",tolua_CEGUI_CEGUI_Window_getActiveChild01);
   tolua_function(tolua_S,"isChild",tolua_CEGUI_CEGUI_Window_isChild00);
   tolua_function(tolua_S,"isChildRecursive",tolua_CEGUI_CEGUI_Window_isChildRecursive00);
   tolua_function(tolua_S,"isAncestor",tolua_CEGUI_CEGUI_Window_isAncestor00);
   tolua_function(tolua_S,"getChildAtIdx",tolua_CEGUI_CEGUI_Window_getChildAtIdx00);
   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,"createChild",tolua_CEGUI_CEGUI_Window_createChild00);
   tolua_function(tolua_S,"destroyChild",tolua_CEGUI_CEGUI_Window_destroyChild00);
   tolua_function(tolua_S,"destroyChild",tolua_CEGUI_CEGUI_Window_destroyChild01);
   tolua_function(tolua_S,"removeChild",tolua_CEGUI_CEGUI_Window_removeChild00);
   tolua_function(tolua_S,"removeChild",tolua_CEGUI_CEGUI_Window_removeChild01);
   tolua_function(tolua_S,"getFont",tolua_CEGUI_CEGUI_Window_getFont00);
   tolua_function(tolua_S,"setFont",tolua_CEGUI_CEGUI_Window_setFont00);
   tolua_function(tolua_S,"setFont",tolua_CEGUI_CEGUI_Window_setFont01);
   tolua_function(tolua_S,"getText",tolua_CEGUI_CEGUI_Window_getText00);
   tolua_function(tolua_S,"getTextVisual",tolua_CEGUI_CEGUI_Window_getTextVisual00);
   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,"inheritsAlpha",tolua_CEGUI_CEGUI_Window_inheritsAlpha00);
   tolua_function(tolua_S,"setInheritsAlpha",tolua_CEGUI_CEGUI_Window_setInheritsAlpha00);
   tolua_function(tolua_S,"getEffectiveAlpha",tolua_CEGUI_CEGUI_Window_getEffectiveAlpha00);
   tolua_function(tolua_S,"getAlpha",tolua_CEGUI_CEGUI_Window_getAlpha00);
   tolua_function(tolua_S,"setAlpha",tolua_CEGUI_CEGUI_Window_setAlpha00);
   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,"getCaptureWindow",tolua_CEGUI_CEGUI_Window_getCaptureWindow00);
   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,"getChildAtPosition",tolua_CEGUI_CEGUI_Window_getChildAtPosition00);
   tolua_function(tolua_S,"getTargetChildAtPosition",tolua_CEGUI_CEGUI_Window_getTargetChildAtPosition00);
   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,"restoresOldCapture",tolua_CEGUI_CEGUI_Window_restoresOldCapture00);
   tolua_function(tolua_S,"setRestoreOldCapture",tolua_CEGUI_CEGUI_Window_setRestoreOldCapture00);
   tolua_function(tolua_S,"captureInput",tolua_CEGUI_CEGUI_Window_captureInput00);
   tolua_function(tolua_S,"releaseInput",tolua_CEGUI_CEGUI_Window_releaseInput00);
   tolua_function(tolua_S,"getZIndex",tolua_CEGUI_CEGUI_Window_getZIndex00);
   tolua_function(tolua_S,"isZOrderingEnabled",tolua_CEGUI_CEGUI_Window_isZOrderingEnabled00);
   tolua_function(tolua_S,"setZOrderingEnabled",tolua_CEGUI_CEGUI_Window_setZOrderingEnabled00);
   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,"isInFront",tolua_CEGUI_CEGUI_Window_isInFront00);
   tolua_function(tolua_S,"isBehind",tolua_CEGUI_CEGUI_Window_isBehind00);
   tolua_function(tolua_S,"wantsMultiClickEvents",tolua_CEGUI_CEGUI_Window_wantsMultiClickEvents00);
   tolua_function(tolua_S,"setWantsMultiClickEvents",tolua_CEGUI_CEGUI_Window_setWantsMultiClickEvents00);
   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,"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,"isMouseInputPropagationEnabled",tolua_CEGUI_CEGUI_Window_isMouseInputPropagationEnabled00);
   tolua_function(tolua_S,"setMouseInputPropagationEnabled",tolua_CEGUI_CEGUI_Window_setMouseInputPropagationEnabled00);
   tolua_function(tolua_S,"isMousePassThroughEnabled",tolua_CEGUI_CEGUI_Window_isMousePassThroughEnabled00);
   tolua_function(tolua_S,"setMousePassThroughEnabled",tolua_CEGUI_CEGUI_Window_setMousePassThroughEnabled00);
   tolua_function(tolua_S,"distributesCapturedInputs",tolua_CEGUI_CEGUI_Window_distributesCapturedInputs00);
   tolua_function(tolua_S,"setDistributesCapturedInputs",tolua_CEGUI_CEGUI_Window_setDistributesCapturedInputs00);
   tolua_function(tolua_S,"isUsingDefaultTooltip",tolua_CEGUI_CEGUI_Window_isUsingDefaultTooltip00);
   tolua_function(tolua_S,"getTooltip",tolua_CEGUI_CEGUI_Window_getTooltip00);
   tolua_function(tolua_S,"setTooltip",tolua_CEGUI_CEGUI_Window_setTooltip00);
   tolua_function(tolua_S,"getTooltipType",tolua_CEGUI_CEGUI_Window_getTooltipType00);
   tolua_function(tolua_S,"setTooltipType",tolua_CEGUI_CEGUI_Window_setTooltipType00);
   tolua_function(tolua_S,"getTooltipText",tolua_CEGUI_CEGUI_Window_getTooltipText00);
   tolua_function(tolua_S,"setTooltipText",tolua_CEGUI_CEGUI_Window_setTooltipText00);
   tolua_function(tolua_S,"setInheritsTooltipText",tolua_CEGUI_CEGUI_Window_setInheritsTooltipText00);
   tolua_function(tolua_S,"inheritsTooltipText",tolua_CEGUI_CEGUI_Window_inheritsTooltipText00);
   tolua_function(tolua_S,"isRiseOnClickEnabled",tolua_CEGUI_CEGUI_Window_isRiseOnClickEnabled00);
   tolua_function(tolua_S,"setRiseOnClickEnabled",tolua_CEGUI_CEGUI_Window_setRiseOnClickEnabled00);
   tolua_function(tolua_S,"getGeometryBuffer",tolua_CEGUI_CEGUI_Window_getGeometryBuffer00);
   tolua_function(tolua_S,"getLookNFeel",tolua_CEGUI_CEGUI_Window_getLookNFeel00);
   tolua_function(tolua_S,"setLookNFeel",tolua_CEGUI_CEGUI_Window_setLookNFeel00);
   tolua_function(tolua_S,"setFalagardType",tolua_CEGUI_CEGUI_Window_setFalagardType00);
   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,"isUserStringDefined",tolua_CEGUI_CEGUI_Window_isUserStringDefined00);
   tolua_function(tolua_S,"getUserString",tolua_CEGUI_CEGUI_Window_getUserString00);
   tolua_function(tolua_S,"setUserString",tolua_CEGUI_CEGUI_Window_setUserString00);
   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,"isWritingXMLAllowed",tolua_CEGUI_CEGUI_Window_isWritingXMLAllowed00);
   tolua_function(tolua_S,"setWritingXMLAllowed",tolua_CEGUI_CEGUI_Window_setWritingXMLAllowed00);
   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,"banPropertyFromXML",tolua_CEGUI_CEGUI_Window_banPropertyFromXML01);
   tolua_function(tolua_S,"unbanPropertyFromXML",tolua_CEGUI_CEGUI_Window_unbanPropertyFromXML01);
   tolua_function(tolua_S,"isPropertyBannedFromXML",tolua_CEGUI_CEGUI_Window_isPropertyBannedFromXML01);
   tolua_function(tolua_S,"getTargetRenderingSurface",tolua_CEGUI_CEGUI_Window_getTargetRenderingSurface00);
   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,"invalidate",tolua_CEGUI_CEGUI_Window_invalidate00);
   tolua_function(tolua_S,"invalidate",tolua_CEGUI_CEGUI_Window_invalidate01);
   tolua_function(tolua_S,"notifyScreenAreaChanged",tolua_CEGUI_CEGUI_Window_notifyScreenAreaChanged00);
   tolua_function(tolua_S,"isTextParsingEnabled",tolua_CEGUI_CEGUI_Window_isTextParsingEnabled00);
   tolua_function(tolua_S,"setTextParsingEnabled",tolua_CEGUI_CEGUI_Window_setTextParsingEnabled00);
   tolua_function(tolua_S,"getMargin",tolua_CEGUI_CEGUI_Window_getMargin00);
   tolua_function(tolua_S,"setMargin",tolua_CEGUI_CEGUI_Window_setMargin00);
   tolua_function(tolua_S,"getUnprojectedPosition",tolua_CEGUI_CEGUI_Window_getUnprojectedPosition00);
   tolua_function(tolua_S,"getUpdateMode",tolua_CEGUI_CEGUI_Window_getUpdateMode00);
   tolua_function(tolua_S,"setUpdateMode",tolua_CEGUI_CEGUI_Window_setUpdateMode00);
   tolua_function(tolua_S,"clone",tolua_CEGUI_CEGUI_Window_clone00);
   tolua_function(tolua_S,"clonePropertiesTo",tolua_CEGUI_CEGUI_Window_clonePropertiesTo00);
   tolua_function(tolua_S,"cloneChildWidgetsTo",tolua_CEGUI_CEGUI_Window_cloneChildWidgetsTo00);
   tolua_function(tolua_S,"getGUIContext",tolua_CEGUI_CEGUI_Window_getGUIContext00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"CoordConverter","CEGUI::CoordConverter","",NULL);
  tolua_beginmodule(tolua_S,"CoordConverter");
   tolua_function(tolua_S,"asAbsolute",tolua_CEGUI_CEGUI_CoordConverter_asAbsolute00);
   tolua_function(tolua_S,"asRelative",tolua_CEGUI_CEGUI_CoordConverter_asRelative00);
   tolua_function(tolua_S,"asAbsolute",tolua_CEGUI_CEGUI_CoordConverter_asAbsolute01);
   tolua_function(tolua_S,"asRelative",tolua_CEGUI_CEGUI_CoordConverter_asRelative01);
   tolua_function(tolua_S,"asAbsolute",tolua_CEGUI_CEGUI_CoordConverter_asAbsolute02);
   tolua_function(tolua_S,"asRelative",tolua_CEGUI_CEGUI_CoordConverter_asRelative02);
   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,"getMajorVersion",tolua_CEGUI_CEGUI_System_getMajorVersion00);
   tolua_function(tolua_S,"getMinorVersion",tolua_CEGUI_CEGUI_System_getMinorVersion00);
   tolua_function(tolua_S,"getPatchVersion",tolua_CEGUI_CEGUI_System_getPatchVersion00);
   tolua_function(tolua_S,"getVersion",tolua_CEGUI_CEGUI_System_getVersion00);
   tolua_function(tolua_S,"getVerboseVersion",tolua_CEGUI_CEGUI_System_getVerboseVersion00);
   tolua_function(tolua_S,"getSingleton",tolua_CEGUI_CEGUI_System_getSingleton00);
   tolua_function(tolua_S,"getRenderer",tolua_CEGUI_CEGUI_System_getRenderer00);
   tolua_function(tolua_S,"getDefaultGUIContext",tolua_CEGUI_CEGUI_System_getDefaultGUIContext00);
   tolua_function(tolua_S,"renderAllGUIContexts",tolua_CEGUI_CEGUI_System_renderAllGUIContexts00);
   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,"notifyDisplaySizeChanged",tolua_CEGUI_CEGUI_System_notifyDisplaySizeChanged00);
   tolua_function(tolua_S,"invalidateAllCachedRendering",tolua_CEGUI_CEGUI_System_invalidateAllCachedRendering00);
   tolua_function(tolua_S,"injectTimePulse",tolua_CEGUI_CEGUI_System_injectTimePulse00);
   tolua_function(tolua_S,"createGUIContext",tolua_CEGUI_CEGUI_System_createGUIContext00);
   tolua_function(tolua_S,"destroyGUIContext",tolua_CEGUI_CEGUI_System_destroyGUIContext00);
   tolua_function(tolua_S,"addStandardWindowFactories",tolua_CEGUI_CEGUI_System_addStandardWindowFactories00);
   tolua_function(tolua_S,"getStringTranscoder",tolua_CEGUI_CEGUI_System_getStringTranscoder00);
   tolua_function(tolua_S,"getEventIterator",tolua_CEGUI_CEGUI_System_getEventIterator00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"GUIContextEventArgs","CEGUI::GUIContextEventArgs","CEGUI::EventArgs",tolua_collect_CEGUI__GUIContextEventArgs);
  #else
  tolua_cclass(tolua_S,"GUIContextEventArgs","CEGUI::GUIContextEventArgs","CEGUI::EventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"GUIContextEventArgs");
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_GUIContextEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_GUIContextEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_GUIContextEventArgs_new00_local);
   tolua_variable(tolua_S,"context",tolua_get_CEGUI__GUIContextEventArgs_context_ptr,tolua_set_CEGUI__GUIContextEventArgs_context_ptr);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"GUIContext","CEGUI::GUIContext","CEGUI::RenderingSurface",NULL);
  tolua_beginmodule(tolua_S,"GUIContext");
   tolua_function(tolua_S,"getRootWindow",tolua_CEGUI_CEGUI_GUIContext_getRootWindow00);
   tolua_function(tolua_S,"setRootWindow",tolua_CEGUI_CEGUI_GUIContext_setRootWindow00);
   tolua_function(tolua_S,"getModalWindow",tolua_CEGUI_CEGUI_GUIContext_getModalWindow00);
   tolua_function(tolua_S,"getWindowContainingMouse",tolua_CEGUI_CEGUI_GUIContext_getWindowContainingMouse00);
   tolua_function(tolua_S,"getSurfaceSize",tolua_CEGUI_CEGUI_GUIContext_getSurfaceSize00);
   tolua_function(tolua_S,"getSystemKeys",tolua_CEGUI_CEGUI_GUIContext_getSystemKeys00);
   tolua_function(tolua_S,"markAsDirty",tolua_CEGUI_CEGUI_GUIContext_markAsDirty00);
   tolua_function(tolua_S,"isDirty",tolua_CEGUI_CEGUI_GUIContext_isDirty00);
   tolua_function(tolua_S,"getMouseCursor",tolua_CEGUI_CEGUI_GUIContext_getMouseCursor00);
   tolua_function(tolua_S,"setMouseMoveScalingFactor",tolua_CEGUI_CEGUI_GUIContext_setMouseMoveScalingFactor00);
   tolua_function(tolua_S,"getMouseMoveScalingFactor",tolua_CEGUI_CEGUI_GUIContext_getMouseMoveScalingFactor00);
   tolua_function(tolua_S,"setMouseButtonClickTimeout",tolua_CEGUI_CEGUI_GUIContext_setMouseButtonClickTimeout00);
   tolua_function(tolua_S,"getMouseButtonClickTimeout",tolua_CEGUI_CEGUI_GUIContext_getMouseButtonClickTimeout00);
   tolua_function(tolua_S,"setMouseButtonMultiClickTimeout",tolua_CEGUI_CEGUI_GUIContext_setMouseButtonMultiClickTimeout00);
   tolua_function(tolua_S,"getMouseButtonMultiClickTimeout",tolua_CEGUI_CEGUI_GUIContext_getMouseButtonMultiClickTimeout00);
   tolua_function(tolua_S,"setMouseButtonMultiClickTolerance",tolua_CEGUI_CEGUI_GUIContext_setMouseButtonMultiClickTolerance00);
   tolua_function(tolua_S,"getMouseButtonMultiClickTolerance",tolua_CEGUI_CEGUI_GUIContext_getMouseButtonMultiClickTolerance00);
   tolua_function(tolua_S,"setMouseClickEventGenerationEnabled",tolua_CEGUI_CEGUI_GUIContext_setMouseClickEventGenerationEnabled00);
   tolua_function(tolua_S,"isMouseClickEventGenerationEnabled",tolua_CEGUI_CEGUI_GUIContext_isMouseClickEventGenerationEnabled00);
   tolua_function(tolua_S,"updateWindowContainingMouse",tolua_CEGUI_CEGUI_GUIContext_updateWindowContainingMouse00);
   tolua_function(tolua_S,"getInputCaptureWindow",tolua_CEGUI_CEGUI_GUIContext_getInputCaptureWindow00);
   tolua_function(tolua_S,"setDefaultTooltipObject",tolua_CEGUI_CEGUI_GUIContext_setDefaultTooltipObject00);
   tolua_function(tolua_S,"setDefaultTooltipType",tolua_CEGUI_CEGUI_GUIContext_setDefaultTooltipType00);
   tolua_function(tolua_S,"getDefaultTooltipObject",tolua_CEGUI_CEGUI_GUIContext_getDefaultTooltipObject00);
   tolua_function(tolua_S,"setDefaultFont",tolua_CEGUI_CEGUI_GUIContext_setDefaultFont00);
   tolua_function(tolua_S,"setDefaultFont",tolua_CEGUI_CEGUI_GUIContext_setDefaultFont01);
   tolua_function(tolua_S,"getDefaultFont",tolua_CEGUI_CEGUI_GUIContext_getDefaultFont00);
   tolua_function(tolua_S,"injectMouseMove",tolua_CEGUI_CEGUI_GUIContext_injectMouseMove00);
   tolua_function(tolua_S,"injectMouseLeaves",tolua_CEGUI_CEGUI_GUIContext_injectMouseLeaves00);
   tolua_function(tolua_S,"injectMouseButtonDown",tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonDown00);
   tolua_function(tolua_S,"injectMouseButtonUp",tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonUp00);
   tolua_function(tolua_S,"injectKeyDown",tolua_CEGUI_CEGUI_GUIContext_injectKeyDown00);
   tolua_function(tolua_S,"injectKeyUp",tolua_CEGUI_CEGUI_GUIContext_injectKeyUp00);
   tolua_function(tolua_S,"injectChar",tolua_CEGUI_CEGUI_GUIContext_injectChar00);
   tolua_function(tolua_S,"injectMouseWheelChange",tolua_CEGUI_CEGUI_GUIContext_injectMouseWheelChange00);
   tolua_function(tolua_S,"injectMousePosition",tolua_CEGUI_CEGUI_GUIContext_injectMousePosition00);
   tolua_function(tolua_S,"injectTimePulse",tolua_CEGUI_CEGUI_GUIContext_injectTimePulse00);
   tolua_function(tolua_S,"injectMouseButtonClick",tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonClick00);
   tolua_function(tolua_S,"injectMouseButtonDoubleClick",tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonDoubleClick00);
   tolua_function(tolua_S,"injectMouseButtonTripleClick",tolua_CEGUI_CEGUI_GUIContext_injectMouseButtonTripleClick00);
   tolua_function(tolua_S,"injectCopyRequest",tolua_CEGUI_CEGUI_GUIContext_injectCopyRequest00);
   tolua_function(tolua_S,"injectCutRequest",tolua_CEGUI_CEGUI_GUIContext_injectCutRequest00);
   tolua_function(tolua_S,"injectPasteRequest",tolua_CEGUI_CEGUI_GUIContext_injectPasteRequest00);
  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,"loadLayoutFromFile",tolua_CEGUI_CEGUI_WindowManager_loadLayoutFromFile00);
   tolua_function(tolua_S,"loadLayoutFromString",tolua_CEGUI_CEGUI_WindowManager_loadLayoutFromString00);
   tolua_function(tolua_S,"writeLayoutToStream",tolua_CEGUI_CEGUI_WindowManager_writeLayoutToStream00);
   tolua_function(tolua_S,"getLayoutAsString",tolua_CEGUI_CEGUI_WindowManager_getLayoutAsString00);
   tolua_function(tolua_S,"saveLayoutToFile",tolua_CEGUI_CEGUI_WindowManager_saveLayoutToFile00);
   tolua_function(tolua_S,"destroyWindow",tolua_CEGUI_CEGUI_WindowManager_destroyWindow00);
   tolua_function(tolua_S,"destroyAllWindows",tolua_CEGUI_CEGUI_WindowManager_destroyAllWindows00);
   tolua_function(tolua_S,"isAlive",tolua_CEGUI_CEGUI_WindowManager_isAlive00);
   tolua_function(tolua_S,"isDeadPoolEmpty",tolua_CEGUI_CEGUI_WindowManager_isDeadPoolEmpty00);
   tolua_function(tolua_S,"cleanDeadPool",tolua_CEGUI_CEGUI_WindowManager_cleanDeadPool00);
   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,"removeAllWindowTypeAliases",tolua_CEGUI_CEGUI_WindowFactoryManager_removeAllWindowTypeAliases00);
   tolua_function(tolua_S,"removeAllFalagardWindowMappings",tolua_CEGUI_CEGUI_WindowFactoryManager_removeAllFalagardWindowMappings00);
   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,"createFromFile",tolua_CEGUI_CEGUI_SchemeManager_createFromFile00);
   tolua_function(tolua_S,"createFromString",tolua_CEGUI_CEGUI_SchemeManager_createFromString00);
   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,"StringTranscoder","CEGUI::StringTranscoder","",NULL);
  tolua_beginmodule(tolua_S,"StringTranscoder");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"PropertyHelper","CEGUI::ceguiLua_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,"stringToVector2",tolua_CEGUI_CEGUI_PropertyHelper_stringToVector200);
   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,"stringToUSize",tolua_CEGUI_CEGUI_PropertyHelper_stringToUSize00);
   tolua_function(tolua_S,"stringToURect",tolua_CEGUI_CEGUI_PropertyHelper_stringToURect00);
   tolua_function(tolua_S,"stringToAspectMode",tolua_CEGUI_CEGUI_PropertyHelper_stringToAspectMode00);
   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,"vector2ToString",tolua_CEGUI_CEGUI_PropertyHelper_vector2ToString00);
   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,"usizeToString",tolua_CEGUI_CEGUI_PropertyHelper_usizeToString00);
   tolua_function(tolua_S,"urectToString",tolua_CEGUI_CEGUI_PropertyHelper_urectToString00);
   tolua_function(tolua_S,"aspectModeToString",tolua_CEGUI_CEGUI_PropertyHelper_aspectModeToString00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"RegexMatchStateEventArgs","CEGUI::RegexMatchStateEventArgs","CEGUI::WindowEventArgs",tolua_collect_CEGUI__RegexMatchStateEventArgs);
  #else
  tolua_cclass(tolua_S,"RegexMatchStateEventArgs","CEGUI::RegexMatchStateEventArgs","CEGUI::WindowEventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"RegexMatchStateEventArgs");
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_RegexMatchStateEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_RegexMatchStateEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_RegexMatchStateEventArgs_new00_local);
   tolua_variable(tolua_S,"matchState",tolua_get_CEGUI__RegexMatchStateEventArgs_matchState,tolua_set_CEGUI__RegexMatchStateEventArgs_matchState);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"RegexMatcher","CEGUI::RegexMatcher","",NULL);
  tolua_beginmodule(tolua_S,"RegexMatcher");
   tolua_constant(tolua_S,"MS_VALID",CEGUI::RegexMatcher::MS_VALID);
   tolua_constant(tolua_S,"MS_INVALID",CEGUI::RegexMatcher::MS_INVALID);
   tolua_constant(tolua_S,"MS_PARTIAL",CEGUI::RegexMatcher::MS_PARTIAL);
   tolua_function(tolua_S,"setRegexString",tolua_CEGUI_CEGUI_RegexMatcher_setRegexString00);
   tolua_function(tolua_S,"getRegexString",tolua_CEGUI_CEGUI_RegexMatcher_getRegexString00);
   tolua_function(tolua_S,"getMatchStateOfString",tolua_CEGUI_CEGUI_RegexMatcher_getMatchStateOfString00);
  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);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"RenderTargetEventArgs","CEGUI::RenderTargetEventArgs","CEGUI::EventArgs",tolua_collect_CEGUI__RenderTargetEventArgs);
  #else
  tolua_cclass(tolua_S,"RenderTargetEventArgs","CEGUI::RenderTargetEventArgs","CEGUI::EventArgs",NULL);
  #endif
  tolua_beginmodule(tolua_S,"RenderTargetEventArgs");
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_RenderTargetEventArgs_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_RenderTargetEventArgs_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_RenderTargetEventArgs_new00_local);
   tolua_variable(tolua_S,"target",tolua_get_CEGUI__RenderTargetEventArgs_target_ptr,tolua_set_CEGUI__RenderTargetEventArgs_target_ptr);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"RenderTarget","CEGUI::RenderTarget","",NULL);
  tolua_beginmodule(tolua_S,"RenderTarget");
   tolua_function(tolua_S,"draw",tolua_CEGUI_CEGUI_RenderTarget_draw00);
   tolua_function(tolua_S,"draw",tolua_CEGUI_CEGUI_RenderTarget_draw01);
   tolua_function(tolua_S,"setArea",tolua_CEGUI_CEGUI_RenderTarget_setArea00);
   tolua_function(tolua_S,"getArea",tolua_CEGUI_CEGUI_RenderTarget_getArea00);
   tolua_function(tolua_S,"isImageryCache",tolua_CEGUI_CEGUI_RenderTarget_isImageryCache00);
   tolua_function(tolua_S,"activate",tolua_CEGUI_CEGUI_RenderTarget_activate00);
   tolua_function(tolua_S,"deactivate",tolua_CEGUI_CEGUI_RenderTarget_deactivate00);
   tolua_function(tolua_S,"unprojectPoint",tolua_CEGUI_CEGUI_RenderTarget_unprojectPoint00);
   tolua_function(tolua_S,"addEvent",tolua_CEGUI_CEGUI_RenderTarget_addEvent00);
   tolua_function(tolua_S,"removeEvent",tolua_CEGUI_CEGUI_RenderTarget_removeEvent00);
   tolua_function(tolua_S,"removeAllEvents",tolua_CEGUI_CEGUI_RenderTarget_removeAllEvents00);
   tolua_function(tolua_S,"isEventPresent",tolua_CEGUI_CEGUI_RenderTarget_isEventPresent00);
   tolua_function(tolua_S,"subscribeEvent",tolua_CEGUI_CEGUI_RenderTarget_subscribeEvent00);
   tolua_function(tolua_S,"subscribeEvent",tolua_CEGUI_CEGUI_RenderTarget_subscribeEvent01);
   tolua_function(tolua_S,"fireEvent",tolua_CEGUI_CEGUI_RenderTarget_fireEvent00);
   tolua_function(tolua_S,"isMuted",tolua_CEGUI_CEGUI_RenderTarget_isMuted00);
   tolua_function(tolua_S,"setMutedState",tolua_CEGUI_CEGUI_RenderTarget_setMutedState00);
   tolua_function(tolua_S,"getEventIterator",tolua_CEGUI_CEGUI_RenderTarget_getEventIterator00);
  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,"RenderQueue","CEGUI::RenderQueue","",NULL);
  tolua_beginmodule(tolua_S,"RenderQueue");
   tolua_function(tolua_S,"addGeometryBuffer",tolua_CEGUI_CEGUI_RenderQueue_addGeometryBuffer00);
   tolua_function(tolua_S,"removeGeometryBuffer",tolua_CEGUI_CEGUI_RenderQueue_removeGeometryBuffer00);
   tolua_function(tolua_S,"draw",tolua_CEGUI_CEGUI_RenderQueue_draw00);
   tolua_function(tolua_S,"reset",tolua_CEGUI_CEGUI_RenderQueue_reset00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Renderer","CEGUI::Renderer","",NULL);
  tolua_beginmodule(tolua_S,"Renderer");
   tolua_function(tolua_S,"getDefaultRenderTarget",tolua_CEGUI_CEGUI_Renderer_getDefaultRenderTarget00);
   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,"createTextureTarget",tolua_CEGUI_CEGUI_Renderer_createTextureTarget00);
   tolua_function(tolua_S,"destroyTextureTarget",tolua_CEGUI_CEGUI_Renderer_destroyTextureTarget00);
   tolua_function(tolua_S,"destroyAllTextureTargets",tolua_CEGUI_CEGUI_Renderer_destroyAllTextureTargets00);
   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,"destroyTexture",tolua_CEGUI_CEGUI_Renderer_destroyTexture01);
   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_function(tolua_S,"getTexture",tolua_CEGUI_CEGUI_Renderer_getTexture00);
   tolua_function(tolua_S,"isTextureDefined",tolua_CEGUI_CEGUI_Renderer_isTextureDefined00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Texture","CEGUI::Texture","",NULL);
  tolua_beginmodule(tolua_S,"Texture");
   tolua_constant(tolua_S,"PixelFormat::Rgb",CEGUI::Texture::PixelFormat::Rgb);
   tolua_constant(tolua_S,"PixelFormat::Rgba",CEGUI::Texture::PixelFormat::Rgba);
   tolua_constant(tolua_S,"PixelFormat::Rgba4444",CEGUI::Texture::PixelFormat::Rgba4444);
   tolua_constant(tolua_S,"PixelFormat::Rgb565",CEGUI::Texture::PixelFormat::Rgb565);
   tolua_constant(tolua_S,"PF_PVRTC2",CEGUI::Texture::PixelFormat::Pvrtc2);
   tolua_constant(tolua_S,"PF_PVRTC4",CEGUI::Texture::PixelFormat::Pvrtc4);
   tolua_constant(tolua_S,"PixelFormat::RgbDxt1",CEGUI::Texture::PixelFormat::RgbDxt1);
   tolua_constant(tolua_S,"PixelFormat::RgbaDxt1",CEGUI::Texture::PixelFormat::RgbaDxt1);
   tolua_constant(tolua_S,"PixelFormat::RgbaDxt3",CEGUI::Texture::PixelFormat::RgbaDxt3);
   tolua_constant(tolua_S,"PixelFormat::RgbaDxt5",CEGUI::Texture::PixelFormat::RgbaDxt5);
   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_function(tolua_S,"isPixelFormatSupported",tolua_CEGUI_CEGUI_Texture_isPixelFormatSupported00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"TextureTarget","CEGUI::TextureTarget","CEGUI::RenderTarget",NULL);
  tolua_beginmodule(tolua_S,"TextureTarget");
   tolua_function(tolua_S,"clear",tolua_CEGUI_CEGUI_TextureTarget_clear00);
   tolua_function(tolua_S,"getTexture",tolua_CEGUI_CEGUI_TextureTarget_getTexture00);
   tolua_function(tolua_S,"declareRenderSize",tolua_CEGUI_CEGUI_TextureTarget_declareRenderSize00);
   tolua_function(tolua_S,"isRenderingInverted",tolua_CEGUI_CEGUI_TextureTarget_isRenderingInverted00);
  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,"autoStepInstances",tolua_CEGUI_CEGUI_AnimationManager_autoStepInstances00);
   tolua_function(tolua_S,"loadAnimationsFromXML",tolua_CEGUI_CEGUI_AnimationManager_loadAnimationsFromXML00);
   tolua_function(tolua_S,"loadAnimationsFromString",tolua_CEGUI_CEGUI_AnimationManager_loadAnimationsFromString00);
   tolua_function(tolua_S,"getAnimationDefinitionAsString",tolua_CEGUI_CEGUI_AnimationManager_getAnimationDefinitionAsString00);
   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,"ToggleButton","CEGUI::ToggleButton","CEGUI::ButtonBase",NULL);
  tolua_beginmodule(tolua_S,"ToggleButton");
   tolua_function(tolua_S,"isSelected",tolua_CEGUI_CEGUI_ToggleButton_isSelected00);
   tolua_function(tolua_S,"setSelected",tolua_CEGUI_CEGUI_ToggleButton_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::ToggleButton",NULL);
  tolua_beginmodule(tolua_S,"RadioButton");
   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,"getTargetWindow",tolua_CEGUI_CEGUI_Tooltip_getTargetWindow00);
   tolua_function(tolua_S,"resetTimer",tolua_CEGUI_CEGUI_Tooltip_resetTimer00);
   tolua_function(tolua_S,"setHoverTime",tolua_CEGUI_CEGUI_Tooltip_setHoverTime00);
   tolua_function(tolua_S,"getHoverTime",tolua_CEGUI_CEGUI_Tooltip_getHoverTime00);
   tolua_function(tolua_S,"setDisplayTime",tolua_CEGUI_CEGUI_Tooltip_setDisplayTime00);
   tolua_function(tolua_S,"getDisplayTime",tolua_CEGUI_CEGUI_Tooltip_getDisplayTime00);
   tolua_function(tolua_S,"positionSelf",tolua_CEGUI_CEGUI_Tooltip_positionSelf00);
   tolua_function(tolua_S,"sizeSelf",tolua_CEGUI_CEGUI_Tooltip_sizeSelf00);
   tolua_function(tolua_S,"getTextSize",tolua_CEGUI_CEGUI_Tooltip_getTextSize00);
  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,"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,"getUnitIntervalScrollPosition",tolua_CEGUI_CEGUI_Scrollbar_getUnitIntervalScrollPosition00);
   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,"setUnitIntervalScrollPosition",tolua_CEGUI_CEGUI_Scrollbar_setUnitIntervalScrollPosition00);
   tolua_function(tolua_S,"setEndLockEnabled",tolua_CEGUI_CEGUI_Scrollbar_setEndLockEnabled00);
   tolua_function(tolua_S,"scrollForwardsByStep",tolua_CEGUI_CEGUI_Scrollbar_scrollForwardsByStep00);
   tolua_function(tolua_S,"scrollBackwardsByStep",tolua_CEGUI_CEGUI_Scrollbar_scrollBackwardsByStep00);
   tolua_function(tolua_S,"scrollForwardsByPage",tolua_CEGUI_CEGUI_Scrollbar_scrollForwardsByPage00);
   tolua_function(tolua_S,"scrollBackwardsByPage",tolua_CEGUI_CEGUI_Scrollbar_scrollBackwardsByPage00);
  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,"getStepSize",tolua_CEGUI_CEGUI_ProgressBar_getStepSize00);
   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,"getTextMatchState",tolua_CEGUI_CEGUI_Editbox_getTextMatchState00);
   tolua_function(tolua_S,"getValidationString",tolua_CEGUI_CEGUI_Editbox_getValidationString00);
   tolua_function(tolua_S,"getCaretIndex",tolua_CEGUI_CEGUI_Editbox_getCaretIndex00);
   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,"setCaretIndex",tolua_CEGUI_CEGUI_Editbox_setCaretIndex00);
   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,"getCaretIndex",tolua_CEGUI_CEGUI_MultiLineEditbox_getCaretIndex00);
   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,"setCaretIndex",tolua_CEGUI_CEGUI_MultiLineEditbox_setCaretIndex00);
   tolua_function(tolua_S,"setSelection",tolua_CEGUI_CEGUI_MultiLineEditbox_setSelection00);
   tolua_function(tolua_S,"setMaxTextLength",tolua_CEGUI_CEGUI_MultiLineEditbox_setMaxTextLength00);
   tolua_function(tolua_S,"ensureCaretIsVisible",tolua_CEGUI_CEGUI_MultiLineEditbox_ensureCaretIsVisible00);
   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,"getTextMatchState",tolua_CEGUI_CEGUI_Combobox_getTextMatchState00);
   tolua_function(tolua_S,"getValidationString",tolua_CEGUI_CEGUI_Combobox_getValidationString00);
   tolua_function(tolua_S,"getCaretIndex",tolua_CEGUI_CEGUI_Combobox_getCaretIndex00);
   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,"setCaretIndex",tolua_CEGUI_CEGUI_Combobox_setCaretIndex00);
   tolua_function(tolua_S,"setSelection",tolua_CEGUI_CEGUI_Combobox_setSelection00);
   tolua_function(tolua_S,"setMaxTextLength",tolua_CEGUI_CEGUI_Combobox_setMaxTextLength00);
   tolua_function(tolua_S,"getAutoSizeListHeightToContent",tolua_CEGUI_CEGUI_Combobox_getAutoSizeListHeightToContent00);
   tolua_function(tolua_S,"getAutoSizeListWidthToContent",tolua_CEGUI_CEGUI_Combobox_getAutoSizeListWidthToContent00);
   tolua_function(tolua_S,"setAutoSizeListHeightToContent",tolua_CEGUI_CEGUI_Combobox_setAutoSizeListHeightToContent00);
   tolua_function(tolua_S,"setAutoSizeListWidthToContent",tolua_CEGUI_CEGUI_Combobox_setAutoSizeListWidthToContent00);
   tolua_function(tolua_S,"updateAutoSizedDropList",tolua_CEGUI_CEGUI_Combobox_updateAutoSizedDropList00);
  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_function(tolua_S,"resizeToContent",tolua_CEGUI_CEGUI_ComboDropList_resizeToContent00);
  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_function(tolua_S,"ensureRowIsVisible",tolua_CEGUI_CEGUI_MultiColumnList_ensureRowIsVisible00);
   tolua_function(tolua_S,"ensureColumnIsVisible",tolua_CEGUI_CEGUI_MultiColumnList_ensureColumnIsVisible00);
   tolua_function(tolua_S,"ensureItemRowIsVisible",tolua_CEGUI_CEGUI_MultiColumnList_ensureItemRowIsVisible00);
   tolua_function(tolua_S,"ensureItemColumnIsVisible",tolua_CEGUI_CEGUI_MultiColumnList_ensureItemColumnIsVisible00);
   tolua_function(tolua_S,"ensureItemIsVisible",tolua_CEGUI_CEGUI_MultiColumnList_ensureItemIsVisible00);
   tolua_function(tolua_S,"ensureItemIsVisible",tolua_CEGUI_CEGUI_MultiColumnList_ensureItemIsVisible01);
   tolua_function(tolua_S,"setAutoSizeColumnUsesHeader",tolua_CEGUI_CEGUI_MultiColumnList_setAutoSizeColumnUsesHeader00);
   tolua_function(tolua_S,"getAutoSizeColumnUsesHeader",tolua_CEGUI_CEGUI_MultiColumnList_getAutoSizeColumnUsesHeader00);
  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,"getPositionOfChild",tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChild00);
   tolua_function(tolua_S,"getPositionOfChild",tolua_CEGUI_CEGUI_SequentialLayoutContainer_getPositionOfChild01);
   tolua_function(tolua_S,"getChildAtPosition",tolua_CEGUI_CEGUI_SequentialLayoutContainer_getChildAtPosition00);
   tolua_function(tolua_S,"swapChildPositions",tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildPositions00);
   tolua_function(tolua_S,"swapChildren",tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren00);
   tolua_function(tolua_S,"swapChildren",tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren01);
   tolua_function(tolua_S,"swapChildren",tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren02);
   tolua_function(tolua_S,"swapChildren",tolua_CEGUI_CEGUI_SequentialLayoutContainer_swapChildren03);
   tolua_function(tolua_S,"moveChildToPosition",tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildToPosition00);
   tolua_function(tolua_S,"moveChildToPosition",tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChildToPosition01);
   tolua_function(tolua_S,"moveChild",tolua_CEGUI_CEGUI_SequentialLayoutContainer_moveChild00);
   tolua_function(tolua_S,"addChildToPosition",tolua_CEGUI_CEGUI_SequentialLayoutContainer_addChildToPosition00);
   tolua_function(tolua_S,"removeChildFromPosition",tolua_CEGUI_CEGUI_SequentialLayoutContainer_removeChildFromPosition00);
  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,"addChildToPosition",tolua_CEGUI_CEGUI_GridLayoutContainer_addChildToPosition00);
   tolua_function(tolua_S,"getChildAtPosition",tolua_CEGUI_CEGUI_GridLayoutContainer_getChildAtPosition00);
   tolua_function(tolua_S,"removeChildFromPosition",tolua_CEGUI_CEGUI_GridLayoutContainer_removeChildFromPosition00);
   tolua_function(tolua_S,"swapChildPositions",tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildPositions00);
   tolua_function(tolua_S,"swapChildPositions",tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildPositions01);
   tolua_function(tolua_S,"swapChildren",tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildren00);
   tolua_function(tolua_S,"swapChildren",tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildren01);
   tolua_function(tolua_S,"swapChildren",tolua_CEGUI_CEGUI_GridLayoutContainer_swapChildren02);
   tolua_function(tolua_S,"moveChildToPosition",tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildToPosition00);
   tolua_function(tolua_S,"moveChildToPosition",tolua_CEGUI_CEGUI_GridLayoutContainer_moveChildToPosition01);
  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_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"OperatorDim","CEGUI::OperatorDim","CEGUI::BaseDim",tolua_collect_CEGUI__OperatorDim);
  #else
  tolua_cclass(tolua_S,"OperatorDim","CEGUI::OperatorDim","CEGUI::BaseDim",NULL);
  #endif
  tolua_beginmodule(tolua_S,"OperatorDim");
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_OperatorDim_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_OperatorDim_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_OperatorDim_new00_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_OperatorDim_new01);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_OperatorDim_new01_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_OperatorDim_new01_local);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_OperatorDim_new02);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_OperatorDim_new02_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_OperatorDim_new02_local);
   tolua_function(tolua_S,"setLeftOperand",tolua_CEGUI_CEGUI_OperatorDim_setLeftOperand00);
   tolua_function(tolua_S,"getLeftOperand",tolua_CEGUI_CEGUI_OperatorDim_getLeftOperand00);
   tolua_function(tolua_S,"setRightOperand",tolua_CEGUI_CEGUI_OperatorDim_setRightOperand00);
   tolua_function(tolua_S,"getRightOperand",tolua_CEGUI_CEGUI_OperatorDim_getRightOperand00);
   tolua_function(tolua_S,"setOperator",tolua_CEGUI_CEGUI_OperatorDim_setOperator00);
   tolua_function(tolua_S,"getOperator",tolua_CEGUI_CEGUI_OperatorDim_getOperator00);
   tolua_function(tolua_S,"setNextOperand",tolua_CEGUI_CEGUI_OperatorDim_setNextOperand00);
  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,"setBaseValue",tolua_CEGUI_CEGUI_AbsoluteDim_setBaseValue00);
   tolua_function(tolua_S,"getBaseValue",tolua_CEGUI_CEGUI_AbsoluteDim_getBaseValue00);
   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);
  tolua_cclass(tolua_S,"ImageDimBase","CEGUI::ImageDimBase","CEGUI::BaseDim",NULL);
  tolua_beginmodule(tolua_S,"ImageDimBase");
   tolua_function(tolua_S,"setSourceDimension",tolua_CEGUI_CEGUI_ImageDimBase_setSourceDimension00);
   tolua_function(tolua_S,"getSourceDimension",tolua_CEGUI_CEGUI_ImageDimBase_getSourceDimension00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"ImageDim","CEGUI::ImageDim","CEGUI::ImageDimBase",tolua_collect_CEGUI__ImageDim);
  #else
  tolua_cclass(tolua_S,"ImageDim","CEGUI::ImageDim","CEGUI::ImageDimBase",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ImageDim");
   tolua_function(tolua_S,"setSourceImage",tolua_CEGUI_CEGUI_ImageDim_setSourceImage00);
   tolua_function(tolua_S,"getSourceImage",tolua_CEGUI_CEGUI_ImageDim_getSourceImage00);
   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,"ImagePropertyDim","CEGUI::ImagePropertyDim","CEGUI::ImageDimBase",tolua_collect_CEGUI__ImagePropertyDim);
  #else
  tolua_cclass(tolua_S,"ImagePropertyDim","CEGUI::ImagePropertyDim","CEGUI::ImageDimBase",NULL);
  #endif
  tolua_beginmodule(tolua_S,"ImagePropertyDim");
   tolua_function(tolua_S,"setSourceProperty",tolua_CEGUI_CEGUI_ImagePropertyDim_setSourceProperty00);
   tolua_function(tolua_S,"getSourceProperty",tolua_CEGUI_CEGUI_ImagePropertyDim_getSourceProperty00);
   tolua_function(tolua_S,"new",tolua_CEGUI_CEGUI_ImagePropertyDim_new00);
   tolua_function(tolua_S,"new_local",tolua_CEGUI_CEGUI_ImagePropertyDim_new00_local);
   tolua_function(tolua_S,".call",tolua_CEGUI_CEGUI_ImagePropertyDim_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,"getWidgetName",tolua_CEGUI_CEGUI_WidgetDim_getWidgetName00);
   tolua_function(tolua_S,"setSourceDimension",tolua_CEGUI_CEGUI_WidgetDim_setSourceDimension00);
   tolua_function(tolua_S,"getSourceDimension",tolua_CEGUI_CEGUI_WidgetDim_getSourceDimension00);
   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,"getBaseValue",tolua_CEGUI_CEGUI_UnifiedDim_getBaseValue00);
   tolua_function(tolua_S,"setBaseValue",tolua_CEGUI_CEGUI_UnifiedDim_setBaseValue00);
   tolua_function(tolua_S,"getSourceDimension",tolua_CEGUI_CEGUI_UnifiedDim_getSourceDimension00);
   tolua_function(tolua_S,"setSourceDimension",tolua_CEGUI_CEGUI_UnifiedDim_setSourceDimension00);
   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,"getName",tolua_CEGUI_CEGUI_FontDim_getName00);
   tolua_function(tolua_S,"setName",tolua_CEGUI_CEGUI_FontDim_setName00);
   tolua_function(tolua_S,"getFont",tolua_CEGUI_CEGUI_FontDim_getFont00);
   tolua_function(tolua_S,"setFont",tolua_CEGUI_CEGUI_FontDim_setFont00);
   tolua_function(tolua_S,"getText",tolua_CEGUI_CEGUI_FontDim_getText00);
   tolua_function(tolua_S,"setText",tolua_CEGUI_CEGUI_FontDim_setText00);
   tolua_function(tolua_S,"getMetric",tolua_CEGUI_CEGUI_FontDim_getMetric00);
   tolua_function(tolua_S,"setMetric",tolua_CEGUI_CEGUI_FontDim_setMetric00);
   tolua_function(tolua_S,"getPadding",tolua_CEGUI_CEGUI_FontDim_getPadding00);
   tolua_function(tolua_S,"setPadding",tolua_CEGUI_CEGUI_FontDim_setPadding00);
   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,"getWidgetName",tolua_CEGUI_CEGUI_PropertyDim_getWidgetName00);
   tolua_function(tolua_S,"setWidgetName",tolua_CEGUI_CEGUI_PropertyDim_setWidgetName00);
   tolua_function(tolua_S,"getPropertyName",tolua_CEGUI_CEGUI_PropertyDim_getPropertyName00);
   tolua_function(tolua_S,"setPropertyName",tolua_CEGUI_CEGUI_PropertyDim_setPropertyName00);
   tolua_function(tolua_S,"getSourceDimension",tolua_CEGUI_CEGUI_PropertyDim_getSourceDimension00);
   tolua_function(tolua_S,"setSourceDimension",tolua_CEGUI_CEGUI_PropertyDim_setSourceDimension00);
   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_function(tolua_S,"setNamedAreaSouce",tolua_CEGUI_CEGUI_ComponentArea_setNamedAreaSouce00);
   tolua_function(tolua_S,"isAreaFetchedFromNamedArea",tolua_CEGUI_CEGUI_ComponentArea_isAreaFetchedFromNamedArea00);
   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);
  #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);
  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_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,"setLeftEdgeFormatting",tolua_CEGUI_CEGUI_FrameComponent_setLeftEdgeFormatting00);
   tolua_function(tolua_S,"setRightEdgeFormatting",tolua_CEGUI_CEGUI_FrameComponent_setRightEdgeFormatting00);
   tolua_function(tolua_S,"setTopEdgeFormatting",tolua_CEGUI_CEGUI_FrameComponent_setTopEdgeFormatting00);
   tolua_function(tolua_S,"setBottomEdgeFormatting",tolua_CEGUI_CEGUI_FrameComponent_setBottomEdgeFormatting00);
   tolua_function(tolua_S,"setBackgroundVerticalFormatting",tolua_CEGUI_CEGUI_FrameComponent_setBackgroundVerticalFormatting00);
   tolua_function(tolua_S,"setBackgroundHorizontalFormatting",tolua_CEGUI_CEGUI_FrameComponent_setBackgroundHorizontalFormatting00);
   tolua_function(tolua_S,"setLeftEdgeFormattingPropertySource",tolua_CEGUI_CEGUI_FrameComponent_setLeftEdgeFormattingPropertySource00);
   tolua_function(tolua_S,"setRightEdgeFormattingPropertySource",tolua_CEGUI_CEGUI_FrameComponent_setRightEdgeFormattingPropertySource00);
   tolua_function(tolua_S,"setTopEdgeFormattingPropertySource",tolua_CEGUI_CEGUI_FrameComponent_setTopEdgeFormattingPropertySource00);
   tolua_function(tolua_S,"setBottomEdgeFormattingPropertySource",tolua_CEGUI_CEGUI_FrameComponent_setBottomEdgeFormattingPropertySource00);
   tolua_function(tolua_S,"setBackgroundVerticalFormattingPropertySource",tolua_CEGUI_CEGUI_FrameComponent_setBackgroundVerticalFormattingPropertySource00);
   tolua_function(tolua_S,"setBackgroundHorizontalFormattingPropertySource",tolua_CEGUI_CEGUI_FrameComponent_setBackgroundHorizontalFormattingPropertySource00);
   tolua_function(tolua_S,"getLeftEdgeFormatting",tolua_CEGUI_CEGUI_FrameComponent_getLeftEdgeFormatting00);
   tolua_function(tolua_S,"getRightEdgeFormatting",tolua_CEGUI_CEGUI_FrameComponent_getRightEdgeFormatting00);
   tolua_function(tolua_S,"getTopEdgeFormatting",tolua_CEGUI_CEGUI_FrameComponent_getTopEdgeFormatting00);
   tolua_function(tolua_S,"getBottomEdgeFormatting",tolua_CEGUI_CEGUI_FrameComponent_getBottomEdgeFormatting00);
   tolua_function(tolua_S,"getBackgroundVerticalFormatting",tolua_CEGUI_CEGUI_FrameComponent_getBackgroundVerticalFormatting00);
   tolua_function(tolua_S,"getBackgroundHorizontalFormatting",tolua_CEGUI_CEGUI_FrameComponent_getBackgroundHorizontalFormatting00);
   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,"setImagePropertySource",tolua_CEGUI_CEGUI_FrameComponent_setImagePropertySource00);
   tolua_function(tolua_S,"isImageSpecified",tolua_CEGUI_CEGUI_FrameComponent_isImageSpecified00);
   tolua_function(tolua_S,"isImageFetchedFromProperty",tolua_CEGUI_CEGUI_FrameComponent_isImageFetchedFromProperty00);
   tolua_function(tolua_S,"getImagePropertySource",tolua_CEGUI_CEGUI_FrameComponent_getImagePropertySource00);
   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,"setHorizontalFormattingPropertySource",tolua_CEGUI_CEGUI_ImageryComponent_setHorizontalFormattingPropertySource00);
   tolua_function(tolua_S,"setVerticalFormattingPropertySource",tolua_CEGUI_CEGUI_ImageryComponent_setVerticalFormattingPropertySource00);
   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,"getEffectiveText",tolua_CEGUI_CEGUI_TextComponent_getEffectiveText00);
   tolua_function(tolua_S,"getTextVisual",tolua_CEGUI_CEGUI_TextComponent_getTextVisual00);
   tolua_function(tolua_S,"getEffectiveVisualText",tolua_CEGUI_CEGUI_TextComponent_getEffectiveVisualText00);
   tolua_function(tolua_S,"setText",tolua_CEGUI_CEGUI_TextComponent_setText00);
   tolua_function(tolua_S,"getFont",tolua_CEGUI_CEGUI_TextComponent_getFont00);
   tolua_function(tolua_S,"getEffectiveFont",tolua_CEGUI_CEGUI_TextComponent_getEffectiveFont00);
   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,"setHorizontalFormattingPropertySource",tolua_CEGUI_CEGUI_TextComponent_setHorizontalFormattingPropertySource00);
   tolua_function(tolua_S,"setVerticalFormattingPropertySource",tolua_CEGUI_CEGUI_TextComponent_setVerticalFormattingPropertySource00);
   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,"getHorizontalTextExtent",tolua_CEGUI_CEGUI_TextComponent_getHorizontalTextExtent00);
   tolua_function(tolua_S,"getVerticalTextExtent",tolua_CEGUI_CEGUI_TextComponent_getVerticalTextExtent00);
   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,"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,"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,"getWidgetName",tolua_CEGUI_CEGUI_WidgetComponent_getWidgetName00);
   tolua_function(tolua_S,"setWidgetName",tolua_CEGUI_CEGUI_WidgetComponent_setWidgetName00);
   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,"setAutoWindow",tolua_CEGUI_CEGUI_WidgetComponent_setAutoWindow00);
   tolua_function(tolua_S,"isAutoWindow",tolua_CEGUI_CEGUI_WidgetComponent_isAutoWindow00);
   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,"clearPropertyDefinitions",tolua_CEGUI_CEGUI_WidgetLookFeel_clearPropertyDefinitions00);
   tolua_function(tolua_S,"clearPropertyLinkDefinitions",tolua_CEGUI_CEGUI_WidgetLookFeel_clearPropertyLinkDefinitions00);
   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,"parseLookNFeelSpecificationFromFile",tolua_CEGUI_CEGUI_WidgetLookManager_parseLookNFeelSpecificationFromFile00);
   tolua_function(tolua_S,"parseLookNFeelSpecificationFromString",tolua_CEGUI_CEGUI_WidgetLookManager_parseLookNFeelSpecificationFromString00);
   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,"eraseAllWidgetLooks",tolua_CEGUI_CEGUI_WidgetLookManager_eraseAllWidgetLooks00);
   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 10");
   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, 84,111,103,103,108,101, 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,111,103,103,108,101, 66,117,116,116,111,110,
    34, 41, 10,101,110,100, 10, 67, 69, 71, 85, 73, 46,116,111,
    67,104,101, 99,107, 98,111,120, 32, 61, 32, 67, 69, 71, 85,
    73, 46,116,111, 84,111,103,103,108,101, 66,117,116,116,111,
   110, 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, 84,111,103,103,108,101, 66,117,
   116,116,111,110, 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,
   103,103,108,101, 66,117,116,116,111,110, 32, 61, 32, 67, 69,
    71, 85, 73, 46,116,111, 84,111,103,103,108,101, 66,117,116,
   116,111,110, 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 11");
   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

