/*
** Lua binding: CEGUI
** Generated automatically by tolua++-1.0.93 on Sat Aug 18 11:49:59 2012.
*/

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

#include "tolua++.h"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* method: isPointInRect of class  CEGUI::Rect */
#ifndef TOLUA_DISABLE_tolua_CEGUI_CEGUI_Rect_isPointInRect00
static int tolua_CEGUI_CEGUI_Rec