Create a new version of paste:

// SGS/CPP-BC
// warning: do not modify this file, it may be regenerated during any build
// generated: 09/27/14 13:53:42

#include "src/ui_control.h"

int UIColor::_sgs_destruct( SGS_CTX, sgs_VarObj* obj )
{
	static_cast<UIColor*>( obj->data )->~UIColor();
	return SGS_SUCCESS;
}

int UIColor::_sgs_gcmark( SGS_CTX, sgs_VarObj* obj )
{
	return SGS_SUCCESS;
}

int UIColor::_sgs_getindex( SGS_ARGS_GETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "r" ){ sgs_PushVar( C, static_cast<UIColor*>( obj->data )->r ); return SGS_SUCCESS; }
		SGS_CASE( "g" ){ sgs_PushVar( C, static_cast<UIColor*>( obj->data )->g ); return SGS_SUCCESS; }
		SGS_CASE( "b" ){ sgs_PushVar( C, static_cast<UIColor*>( obj->data )->b ); return SGS_SUCCESS; }
		SGS_CASE( "a" ){ sgs_PushVar( C, static_cast<UIColor*>( obj->data )->a ); return SGS_SUCCESS; }
		SGS_CASE( "size" ){ sgs_PushVar( C, static_cast<UIColor*>( obj->data )->_get_size() ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIColor::_sgs_setindex( SGS_ARGS_SETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "r" ){ static_cast<UIColor*>( obj->data )->r = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "g" ){ static_cast<UIColor*>( obj->data )->g = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "b" ){ static_cast<UIColor*>( obj->data )->b = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "a" ){ static_cast<UIColor*>( obj->data )->a = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIColor::_sgs_dump( SGS_CTX, sgs_VarObj* obj, int depth )
{
	char bfr[ 39 ];
	sprintf( bfr, "UIColor (%p) %s", obj->data, depth > 0 ? "\n{" : " ..." );
	sgs_PushString( C, bfr );
	if( depth > 0 )
	{
		{ sgs_PushString( C, "\nr = " ); sgs_DumpData( C, static_cast<UIColor*>( obj->data )->r, depth ).push( C ); }
		{ sgs_PushString( C, "\ng = " ); sgs_DumpData( C, static_cast<UIColor*>( obj->data )->g, depth ).push( C ); }
		{ sgs_PushString( C, "\nb = " ); sgs_DumpData( C, static_cast<UIColor*>( obj->data )->b, depth ).push( C ); }
		{ sgs_PushString( C, "\na = " ); sgs_DumpData( C, static_cast<UIColor*>( obj->data )->a, depth ).push( C ); }
		{ sgs_PushString( C, "\nsize = " ); sgs_DumpData( C, static_cast<UIColor*>( obj->data )->_get_size(), depth ).push( C ); }
		sgs_StringConcat( C, 10 );
		sgs_PadString( C );
		sgs_PushString( C, "\n}" );
		sgs_StringConcat( C, 3 );
	}
	return SGS_SUCCESS;
}

sgs_ObjInterface UIColor::_sgs_interface[1] =
{{
	"UIColor",
	UIColor::_sgs_destruct, UIColor::_sgs_gcmark, UIColor::sgs_getindex, UIColor::_sgs_setindex, NULL, NULL, UIColor::_sgs_dump, NULL, NULL, UIColor::sgs_expr, 
}};


int UIEvent::_sgs_destruct( SGS_CTX, sgs_VarObj* obj )
{
	static_cast<UIEvent*>( obj->data )->~UIEvent();
	return SGS_SUCCESS;
}

int UIEvent::_sgs_gcmark( SGS_CTX, sgs_VarObj* obj )
{
	return SGS_SUCCESS;
}

int UIEvent::_sgs_getindex( SGS_ARGS_GETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "type" ){ sgs_PushVar( C, static_cast<UIEvent*>( obj->data )->type ); return SGS_SUCCESS; }
		SGS_CASE( "key" ){ sgs_PushVar( C, static_cast<UIEvent*>( obj->data )->key ); return SGS_SUCCESS; }
		SGS_CASE( "subtype" ){ sgs_PushVar( C, static_cast<UIEvent*>( obj->data )->key ); return SGS_SUCCESS; }
		SGS_CASE( "button" ){ sgs_PushVar( C, static_cast<UIEvent*>( obj->data )->key ); return SGS_SUCCESS; }
		SGS_CASE( "uchar" ){ sgs_PushVar( C, static_cast<UIEvent*>( obj->data )->uchar ); return SGS_SUCCESS; }
		SGS_CASE( "clicks" ){ sgs_PushVar( C, static_cast<UIEvent*>( obj->data )->uchar ); return SGS_SUCCESS; }
		SGS_CASE( "x" ){ sgs_PushVar( C, static_cast<UIEvent*>( obj->data )->x ); return SGS_SUCCESS; }
		SGS_CASE( "y" ){ sgs_PushVar( C, static_cast<UIEvent*>( obj->data )->y ); return SGS_SUCCESS; }
		SGS_CASE( "rx" ){ sgs_PushVar( C, static_cast<UIEvent*>( obj->data )->rx ); return SGS_SUCCESS; }
		SGS_CASE( "ry" ){ sgs_PushVar( C, static_cast<UIEvent*>( obj->data )->ry ); return SGS_SUCCESS; }
		SGS_CASE( "target" ){ sgs_PushVar( C, static_cast<UIEvent*>( obj->data )->target ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIEvent::_sgs_setindex( SGS_ARGS_SETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "type" ){ static_cast<UIEvent*>( obj->data )->type = sgs_GetVarP<int>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "key" ){ static_cast<UIEvent*>( obj->data )->key = sgs_GetVarP<int>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "subtype" ){ static_cast<UIEvent*>( obj->data )->key = sgs_GetVarP<int>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "button" ){ static_cast<UIEvent*>( obj->data )->key = sgs_GetVarP<int>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "uchar" ){ static_cast<UIEvent*>( obj->data )->uchar = sgs_GetVarP<uint32_t>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "clicks" ){ static_cast<UIEvent*>( obj->data )->uchar = sgs_GetVarP<uint32_t>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "x" ){ static_cast<UIEvent*>( obj->data )->x = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "y" ){ static_cast<UIEvent*>( obj->data )->y = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "rx" ){ static_cast<UIEvent*>( obj->data )->rx = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "ry" ){ static_cast<UIEvent*>( obj->data )->ry = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "target" ){ static_cast<UIEvent*>( obj->data )->target = sgs_GetVarP<sgsHandle<struct UIControl> >()( C, val ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIEvent::_sgs_dump( SGS_CTX, sgs_VarObj* obj, int depth )
{
	char bfr[ 39 ];
	sprintf( bfr, "UIEvent (%p) %s", obj->data, depth > 0 ? "\n{" : " ..." );
	sgs_PushString( C, bfr );
	if( depth > 0 )
	{
		{ sgs_PushString( C, "\ntype = " ); sgs_DumpData( C, static_cast<UIEvent*>( obj->data )->type, depth ).push( C ); }
		{ sgs_PushString( C, "\nkey = " ); sgs_DumpData( C, static_cast<UIEvent*>( obj->data )->key, depth ).push( C ); }
		{ sgs_PushString( C, "\nuchar = " ); sgs_DumpData( C, static_cast<UIEvent*>( obj->data )->uchar, depth ).push( C ); }
		{ sgs_PushString( C, "\nx = " ); sgs_DumpData( C, static_cast<UIEvent*>( obj->data )->x, depth ).push( C ); }
		{ sgs_PushString( C, "\ny = " ); sgs_DumpData( C, static_cast<UIEvent*>( obj->data )->y, depth ).push( C ); }
		{ sgs_PushString( C, "\nrx = " ); sgs_DumpData( C, static_cast<UIEvent*>( obj->data )->rx, depth ).push( C ); }
		{ sgs_PushString( C, "\nry = " ); sgs_DumpData( C, static_cast<UIEvent*>( obj->data )->ry, depth ).push( C ); }
		{ sgs_PushString( C, "\ntarget = " ); sgs_DumpData( C, static_cast<UIEvent*>( obj->data )->target, depth ).push( C ); }
		sgs_StringConcat( C, 16 );
		sgs_PadString( C );
		sgs_PushString( C, "\n}" );
		sgs_StringConcat( C, 3 );
	}
	return SGS_SUCCESS;
}

sgs_ObjInterface UIEvent::_sgs_interface[1] =
{{
	"UIEvent",
	UIEvent::_sgs_destruct, UIEvent::_sgs_gcmark, UIEvent::_sgs_getindex, UIEvent::_sgs_setindex, NULL, NULL, UIEvent::_sgs_dump, NULL, NULL, NULL, 
}};


int UIStyle::_sgs_destruct( SGS_CTX, sgs_VarObj* obj )
{
	static_cast<UIStyle*>( obj->data )->~UIStyle();
	return SGS_SUCCESS;
}

int UIStyle::_sgs_gcmark( SGS_CTX, sgs_VarObj* obj )
{
	return SGS_SUCCESS;
}

int UIStyle::_sgs_getindex( SGS_ARGS_GETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "x" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->x ); return SGS_SUCCESS; }
		SGS_CASE( "y" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->y ); return SGS_SUCCESS; }
		SGS_CASE( "width" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->width ); return SGS_SUCCESS; }
		SGS_CASE( "height" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->height ); return SGS_SUCCESS; }
		SGS_CASE( "q0x" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->q0x ); return SGS_SUCCESS; }
		SGS_CASE( "q0y" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->q0y ); return SGS_SUCCESS; }
		SGS_CASE( "q1x" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->q1x ); return SGS_SUCCESS; }
		SGS_CASE( "q1y" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->q1y ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientTop" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->nonClientTop ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientLeft" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->nonClientLeft ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientRight" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->nonClientRight ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientBottom" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->nonClientBottom ); return SGS_SUCCESS; }
		SGS_CASE( "visible" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->visible ); return SGS_SUCCESS; }
		SGS_CASE( "index" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->index ); return SGS_SUCCESS; }
		SGS_CASE( "topmost" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->topmost ); return SGS_SUCCESS; }
		SGS_CASE( "minWidth" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->minWidth ); return SGS_SUCCESS; }
		SGS_CASE( "maxWidth" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->maxWidth ); return SGS_SUCCESS; }
		SGS_CASE( "minHeight" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->minHeight ); return SGS_SUCCESS; }
		SGS_CASE( "maxHeight" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->maxHeight ); return SGS_SUCCESS; }
		SGS_CASE( "marginLeft" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->marginLeft ); return SGS_SUCCESS; }
		SGS_CASE( "marginRight" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->marginRight ); return SGS_SUCCESS; }
		SGS_CASE( "marginTop" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->marginTop ); return SGS_SUCCESS; }
		SGS_CASE( "marginBottom" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->marginBottom ); return SGS_SUCCESS; }
		SGS_CASE( "paddingLeft" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->paddingLeft ); return SGS_SUCCESS; }
		SGS_CASE( "paddingRight" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->paddingRight ); return SGS_SUCCESS; }
		SGS_CASE( "paddingTop" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->paddingTop ); return SGS_SUCCESS; }
		SGS_CASE( "paddingBottom" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->paddingBottom ); return SGS_SUCCESS; }
		SGS_CASE( "posMode" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->posMode ); return SGS_SUCCESS; }
		SGS_CASE( "stackMode" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->stackMode ); return SGS_SUCCESS; }
		SGS_CASE( "overflow" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->overflow ); return SGS_SUCCESS; }
		SGS_CASE( "backgroundColor" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->backgroundColor ); return SGS_SUCCESS; }
		SGS_CASE( "textColor" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->textColor ); return SGS_SUCCESS; }
		SGS_CASE( "halign" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->halign ); return SGS_SUCCESS; }
		SGS_CASE( "valign" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->valign ); return SGS_SUCCESS; }
		SGS_CASE( "cursor" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->cursor ); return SGS_SUCCESS; }
		SGS_CASE( "font" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->font ); return SGS_SUCCESS; }
		SGS_CASE( "fontSize" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->fontSize ); return SGS_SUCCESS; }
		SGS_CASE( "image" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->image ); return SGS_SUCCESS; }
		SGS_CASE( "icon" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->icon ); return SGS_SUCCESS; }
		SGS_CASE( "renderfunc" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->renderfunc ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientH" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->get_nonClientH() ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientV" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->get_nonClientV() ); return SGS_SUCCESS; }
		SGS_CASE( "nonClient" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->get_nonClient() ); return SGS_SUCCESS; }
		SGS_CASE( "marginH" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->get_marginH() ); return SGS_SUCCESS; }
		SGS_CASE( "marginV" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->get_marginV() ); return SGS_SUCCESS; }
		SGS_CASE( "margin" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->get_margin() ); return SGS_SUCCESS; }
		SGS_CASE( "paddingH" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->get_paddingH() ); return SGS_SUCCESS; }
		SGS_CASE( "paddingV" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->get_paddingV() ); return SGS_SUCCESS; }
		SGS_CASE( "padding" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->get_padding() ); return SGS_SUCCESS; }
		SGS_CASE( "anchorMode" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->get_anchorMode() ); return SGS_SUCCESS; }
		SGS_CASE( "align" ){ sgs_PushVar( C, static_cast<UIStyle*>( obj->data )->get_align() ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIStyle::_sgs_setindex( SGS_ARGS_SETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "x" ){ static_cast<UIStyle*>( obj->data )->x = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "y" ){ static_cast<UIStyle*>( obj->data )->y = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "width" ){ static_cast<UIStyle*>( obj->data )->width = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "height" ){ static_cast<UIStyle*>( obj->data )->height = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "q0x" ){ static_cast<UIStyle*>( obj->data )->q0x = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "q0y" ){ static_cast<UIStyle*>( obj->data )->q0y = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "q1x" ){ static_cast<UIStyle*>( obj->data )->q1x = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "q1y" ){ static_cast<UIStyle*>( obj->data )->q1y = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientTop" ){ static_cast<UIStyle*>( obj->data )->nonClientTop = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientLeft" ){ static_cast<UIStyle*>( obj->data )->nonClientLeft = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientRight" ){ static_cast<UIStyle*>( obj->data )->nonClientRight = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientBottom" ){ static_cast<UIStyle*>( obj->data )->nonClientBottom = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "visible" ){ static_cast<UIStyle*>( obj->data )->visible = sgs_GetVarP<sgsMaybe<bool> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "index" ){ static_cast<UIStyle*>( obj->data )->index = sgs_GetVarP<sgsMaybe<int> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "topmost" ){ static_cast<UIStyle*>( obj->data )->topmost = sgs_GetVarP<sgsMaybe<bool> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "minWidth" ){ static_cast<UIStyle*>( obj->data )->minWidth = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "maxWidth" ){ static_cast<UIStyle*>( obj->data )->maxWidth = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "minHeight" ){ static_cast<UIStyle*>( obj->data )->minHeight = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "maxHeight" ){ static_cast<UIStyle*>( obj->data )->maxHeight = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "marginLeft" ){ static_cast<UIStyle*>( obj->data )->marginLeft = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "marginRight" ){ static_cast<UIStyle*>( obj->data )->marginRight = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "marginTop" ){ static_cast<UIStyle*>( obj->data )->marginTop = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "marginBottom" ){ static_cast<UIStyle*>( obj->data )->marginBottom = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "paddingLeft" ){ static_cast<UIStyle*>( obj->data )->paddingLeft = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "paddingRight" ){ static_cast<UIStyle*>( obj->data )->paddingRight = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "paddingTop" ){ static_cast<UIStyle*>( obj->data )->paddingTop = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "paddingBottom" ){ static_cast<UIStyle*>( obj->data )->paddingBottom = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "posMode" ){ static_cast<UIStyle*>( obj->data )->posMode = sgs_GetVarP<sgsMaybe<int8_t> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "stackMode" ){ static_cast<UIStyle*>( obj->data )->stackMode = sgs_GetVarP<sgsMaybe<int8_t> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "overflow" ){ static_cast<UIStyle*>( obj->data )->overflow = sgs_GetVarP<sgsMaybe<bool> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "backgroundColor" ){ static_cast<UIStyle*>( obj->data )->backgroundColor = sgs_GetVarP<sgsMaybe<UIColor> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "textColor" ){ static_cast<UIStyle*>( obj->data )->textColor = sgs_GetVarP<sgsMaybe<UIColor> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "halign" ){ static_cast<UIStyle*>( obj->data )->halign = sgs_GetVarP<sgsMaybe<uint16_t> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "valign" ){ static_cast<UIStyle*>( obj->data )->valign = sgs_GetVarP<sgsMaybe<uint16_t> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "cursor" ){ static_cast<UIStyle*>( obj->data )->cursor = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "font" ){ static_cast<UIStyle*>( obj->data )->font = sgs_GetVarP<sgsString>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "fontSize" ){ static_cast<UIStyle*>( obj->data )->fontSize = sgs_GetVarP<sgsMaybe<float> >()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "image" ){ static_cast<UIStyle*>( obj->data )->image = sgs_GetVarP<sgsString>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "icon" ){ static_cast<UIStyle*>( obj->data )->icon = sgs_GetVarP<sgsString>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "renderfunc" ){ static_cast<UIStyle*>( obj->data )->renderfunc = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientH" ){ static_cast<UIStyle*>( obj->data )->set_nonClientH( sgs_GetVarP<float>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientV" ){ static_cast<UIStyle*>( obj->data )->set_nonClientV( sgs_GetVarP<float>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "nonClient" ){ static_cast<UIStyle*>( obj->data )->set_nonClient( sgs_GetVarP<float>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "marginH" ){ static_cast<UIStyle*>( obj->data )->set_marginH( sgs_GetVarP<float>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "marginV" ){ static_cast<UIStyle*>( obj->data )->set_marginV( sgs_GetVarP<float>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "margin" ){ static_cast<UIStyle*>( obj->data )->set_margin( sgs_GetVarP<float>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "paddingH" ){ static_cast<UIStyle*>( obj->data )->set_paddingH( sgs_GetVarP<float>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "paddingV" ){ static_cast<UIStyle*>( obj->data )->set_paddingV( sgs_GetVarP<float>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "padding" ){ static_cast<UIStyle*>( obj->data )->set_padding( sgs_GetVarP<float>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "anchorMode" ){ static_cast<UIStyle*>( obj->data )->set_anchorMode( sgs_GetVarP<int>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "align" ){ static_cast<UIStyle*>( obj->data )->set_align( sgs_GetVarP<uint16_t>()( C, val ) ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIStyle::_sgs_dump( SGS_CTX, sgs_VarObj* obj, int depth )
{
	char bfr[ 39 ];
	sprintf( bfr, "UIStyle (%p) %s", obj->data, depth > 0 ? "\n{" : " ..." );
	sgs_PushString( C, bfr );
	if( depth > 0 )
	{
		{ sgs_PushString( C, "\nx = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->x, depth ).push( C ); }
		{ sgs_PushString( C, "\ny = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->y, depth ).push( C ); }
		{ sgs_PushString( C, "\nwidth = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->width, depth ).push( C ); }
		{ sgs_PushString( C, "\nheight = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->height, depth ).push( C ); }
		{ sgs_PushString( C, "\nq0x = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->q0x, depth ).push( C ); }
		{ sgs_PushString( C, "\nq0y = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->q0y, depth ).push( C ); }
		{ sgs_PushString( C, "\nq1x = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->q1x, depth ).push( C ); }
		{ sgs_PushString( C, "\nq1y = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->q1y, depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClientTop = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->nonClientTop, depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClientLeft = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->nonClientLeft, depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClientRight = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->nonClientRight, depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClientBottom = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->nonClientBottom, depth ).push( C ); }
		{ sgs_PushString( C, "\nvisible = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->visible, depth ).push( C ); }
		{ sgs_PushString( C, "\nindex = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->index, depth ).push( C ); }
		{ sgs_PushString( C, "\ntopmost = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->topmost, depth ).push( C ); }
		{ sgs_PushString( C, "\nminWidth = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->minWidth, depth ).push( C ); }
		{ sgs_PushString( C, "\nmaxWidth = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->maxWidth, depth ).push( C ); }
		{ sgs_PushString( C, "\nminHeight = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->minHeight, depth ).push( C ); }
		{ sgs_PushString( C, "\nmaxHeight = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->maxHeight, depth ).push( C ); }
		{ sgs_PushString( C, "\nmarginLeft = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->marginLeft, depth ).push( C ); }
		{ sgs_PushString( C, "\nmarginRight = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->marginRight, depth ).push( C ); }
		{ sgs_PushString( C, "\nmarginTop = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->marginTop, depth ).push( C ); }
		{ sgs_PushString( C, "\nmarginBottom = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->marginBottom, depth ).push( C ); }
		{ sgs_PushString( C, "\npaddingLeft = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->paddingLeft, depth ).push( C ); }
		{ sgs_PushString( C, "\npaddingRight = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->paddingRight, depth ).push( C ); }
		{ sgs_PushString( C, "\npaddingTop = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->paddingTop, depth ).push( C ); }
		{ sgs_PushString( C, "\npaddingBottom = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->paddingBottom, depth ).push( C ); }
		{ sgs_PushString( C, "\nposMode = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->posMode, depth ).push( C ); }
		{ sgs_PushString( C, "\nstackMode = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->stackMode, depth ).push( C ); }
		{ sgs_PushString( C, "\noverflow = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->overflow, depth ).push( C ); }
		{ sgs_PushString( C, "\nbackgroundColor = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->backgroundColor, depth ).push( C ); }
		{ sgs_PushString( C, "\ntextColor = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->textColor, depth ).push( C ); }
		{ sgs_PushString( C, "\nhalign = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->halign, depth ).push( C ); }
		{ sgs_PushString( C, "\nvalign = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->valign, depth ).push( C ); }
		{ sgs_PushString( C, "\ncursor = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->cursor, depth ).push( C ); }
		{ sgs_PushString( C, "\nfont = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->font, depth ).push( C ); }
		{ sgs_PushString( C, "\nfontSize = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->fontSize, depth ).push( C ); }
		{ sgs_PushString( C, "\nimage = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->image, depth ).push( C ); }
		{ sgs_PushString( C, "\nicon = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->icon, depth ).push( C ); }
		{ sgs_PushString( C, "\nrenderfunc = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->renderfunc, depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClientH = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->get_nonClientH(), depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClientV = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->get_nonClientV(), depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClient = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->get_nonClient(), depth ).push( C ); }
		{ sgs_PushString( C, "\nmarginH = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->get_marginH(), depth ).push( C ); }
		{ sgs_PushString( C, "\nmarginV = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->get_marginV(), depth ).push( C ); }
		{ sgs_PushString( C, "\nmargin = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->get_margin(), depth ).push( C ); }
		{ sgs_PushString( C, "\npaddingH = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->get_paddingH(), depth ).push( C ); }
		{ sgs_PushString( C, "\npaddingV = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->get_paddingV(), depth ).push( C ); }
		{ sgs_PushString( C, "\npadding = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->get_padding(), depth ).push( C ); }
		{ sgs_PushString( C, "\nanchorMode = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->get_anchorMode(), depth ).push( C ); }
		{ sgs_PushString( C, "\nalign = " ); sgs_DumpData( C, static_cast<UIStyle*>( obj->data )->get_align(), depth ).push( C ); }
		sgs_StringConcat( C, 102 );
		sgs_PadString( C );
		sgs_PushString( C, "\n}" );
		sgs_StringConcat( C, 3 );
	}
	return SGS_SUCCESS;
}

sgs_ObjInterface UIStyle::_sgs_interface[1] =
{{
	"UIStyle",
	UIStyle::_sgs_destruct, UIStyle::_sgs_gcmark, UIStyle::_sgs_getindex, UIStyle::_sgs_setindex, NULL, NULL, UIStyle::_sgs_dump, NULL, NULL, NULL, 
}};


static int _sgs_method__UIStyleRule__addSelector( SGS_CTX )
{
	UIStyleRule* data; if( !SGS_PARSE_METHOD( C, UIStyleRule::_sgs_interface, data, UIStyleRule, addSelector ) ) return 0;
	return data->addSelector( sgs_GetVar<sgsString>()(C,0) );
}

static int _sgs_method__UIStyleRule__addSelectors( SGS_CTX )
{
	UIStyleRule* data; if( !SGS_PARSE_METHOD( C, UIStyleRule::_sgs_interface, data, UIStyleRule, addSelectors ) ) return 0;
	return data->addSelectors( sgs_GetVar<sgsString>()(C,0) );
}

static int _sgs_method__UIStyleRule__checkMatch( SGS_CTX )
{
	UIStyleRule* data; if( !SGS_PARSE_METHOD( C, UIStyleRule::_sgs_interface, data, UIStyleRule, checkMatch ) ) return 0;
	sgs_PushVar(C,data->checkMatch( sgs_GetVar<sgsHandle< struct UIControl > >()(C,0) )); return 1;
}

int UIStyleRule::_sgs_destruct( SGS_CTX, sgs_VarObj* obj )
{
	static_cast<UIStyleRule*>( obj->data )->~UIStyleRule();
	return SGS_SUCCESS;
}

int UIStyleRule::_sgs_gcmark( SGS_CTX, sgs_VarObj* obj )
{
	return SGS_SUCCESS;
}

int UIStyleRule::_sgs_getindex( SGS_ARGS_GETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "style" ){ sgs_PushVar( C, static_cast<UIStyleRule*>( obj->data )->style ); return SGS_SUCCESS; }
		SGS_CASE( "addSelector" ){ sgs_PushCFunction( C, _sgs_method__UIStyleRule__addSelector ); return SGS_SUCCESS; }
		SGS_CASE( "addSelectors" ){ sgs_PushCFunction( C, _sgs_method__UIStyleRule__addSelectors ); return SGS_SUCCESS; }
		SGS_CASE( "checkMatch" ){ sgs_PushCFunction( C, _sgs_method__UIStyleRule__checkMatch ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIStyleRule::_sgs_setindex( SGS_ARGS_SETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "style" ){ static_cast<UIStyleRule*>( obj->data )->style = sgs_GetVarP<UIStyle>()( C, val ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIStyleRule::_sgs_dump( SGS_CTX, sgs_VarObj* obj, int depth )
{
	char bfr[ 43 ];
	sprintf( bfr, "UIStyleRule (%p) %s", obj->data, depth > 0 ? "\n{" : " ..." );
	sgs_PushString( C, bfr );
	if( depth > 0 )
	{
		{ sgs_PushString( C, "\nstyle = " ); sgs_DumpData( C, static_cast<UIStyleRule*>( obj->data )->style, depth ).push( C ); }
		sgs_StringConcat( C, 2 );
		sgs_PadString( C );
		sgs_PushString( C, "\n}" );
		sgs_StringConcat( C, 3 );
	}
	return SGS_SUCCESS;
}

sgs_ObjInterface UIStyleRule::_sgs_interface[1] =
{{
	"UIStyleRule",
	UIStyleRule::_sgs_destruct, UIStyleRule::_sgs_gcmark, UIStyleRule::_sgs_getindex, UIStyleRule::_sgs_setindex, NULL, NULL, UIStyleRule::_sgs_dump, NULL, NULL, NULL, 
}};


static int _sgs_method__UIStyleSheet__addRule( SGS_CTX )
{
	UIStyleSheet* data; if( !SGS_PARSE_METHOD( C, UIStyleSheet::_sgs_interface, data, UIStyleSheet, addRule ) ) return 0;
	return data->addRule( sgs_GetVar<UIStyleRule::Handle>()(C,0) );
}

static int _sgs_method__UIStyleSheet__build( SGS_CTX )
{
	UIStyleSheet* data; if( !SGS_PARSE_METHOD( C, UIStyleSheet::_sgs_interface, data, UIStyleSheet, build ) ) return 0;
	data->build( sgs_GetVar<sgsVariable>()(C,0) ); return 0;
}

int UIStyleSheet::_sgs_destruct( SGS_CTX, sgs_VarObj* obj )
{
	static_cast<UIStyleSheet*>( obj->data )->~UIStyleSheet();
	return SGS_SUCCESS;
}

int UIStyleSheet::_sgs_gcmark( SGS_CTX, sgs_VarObj* obj )
{
	return SGS_SUCCESS;
}

int UIStyleSheet::_sgs_getindex( SGS_ARGS_GETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "ruleCount" ){ sgs_PushVar( C, static_cast<UIStyleSheet*>( obj->data )->_get_ruleCount() ); return SGS_SUCCESS; }
		SGS_CASE( "addRule" ){ sgs_PushCFunction( C, _sgs_method__UIStyleSheet__addRule ); return SGS_SUCCESS; }
		SGS_CASE( "build" ){ sgs_PushCFunction( C, _sgs_method__UIStyleSheet__build ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIStyleSheet::_sgs_setindex( SGS_ARGS_SETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
	SGS_END_INDEXFUNC;
}

int UIStyleSheet::_sgs_dump( SGS_CTX, sgs_VarObj* obj, int depth )
{
	char bfr[ 44 ];
	sprintf( bfr, "UIStyleSheet (%p) %s", obj->data, depth > 0 ? "\n{" : " ..." );
	sgs_PushString( C, bfr );
	if( depth > 0 )
	{
		{ sgs_PushString( C, "\nruleCount = " ); sgs_DumpData( C, static_cast<UIStyleSheet*>( obj->data )->_get_ruleCount(), depth ).push( C ); }
		sgs_StringConcat( C, 2 );
		sgs_PadString( C );
		sgs_PushString( C, "\n}" );
		sgs_StringConcat( C, 3 );
	}
	return SGS_SUCCESS;
}

sgs_ObjInterface UIStyleSheet::_sgs_interface[1] =
{{
	"UIStyleSheet",
	UIStyleSheet::_sgs_destruct, UIStyleSheet::sgs_gcmark, UIStyleSheet::_sgs_getindex, UIStyleSheet::_sgs_setindex, NULL, NULL, UIStyleSheet::_sgs_dump, NULL, NULL, NULL, 
}};


static int _sgs_method__UIFrame__createControl( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, createControl ) ) return 0;
	sgs_PushVar(C,data->createControl( sgs_GetVar<sgsString>()(C,0) )); return 1;
}

static int _sgs_method__UIFrame__find( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, find ) ) return 0;
	sgs_PushVar(C,data->find(  )); return 1;
}

static int _sgs_method__UIFrame__event( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, event ) ) return 0;
	data->event( sgs_GetVar<sgsVariable>()(C,0) ); return 0;
}

static int _sgs_method__UIFrame__render( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, render ) ) return 0;
	data->render(  ); return 0;
}

static int _sgs_method__UIFrame__handleMouseMove( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, handleMouseMove ) ) return 0;
	data->handleMouseMove( sgs_GetVar<bool>()(C,0) ); return 0;
}

static int _sgs_method__UIFrame__setFocus( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, setFocus ) ) return 0;
	data->setFocus( sgs_GetVarObj<UIControl>()(C,0) ); return 0;
}

static int _sgs_method__UIFrame__doMouseMove( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, doMouseMove ) ) return 0;
	data->doMouseMove( sgs_GetVar<float>()(C,0), sgs_GetVar<float>()(C,1) ); return 0;
}

static int _sgs_method__UIFrame__doMouseButton( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, doMouseButton ) ) return 0;
	data->doMouseButton( sgs_GetVar<int>()(C,0), sgs_GetVar<bool>()(C,1) ); return 0;
}

static int _sgs_method__UIFrame__doMouseWheel( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, doMouseWheel ) ) return 0;
	data->doMouseWheel( sgs_GetVar<float>()(C,0), sgs_GetVar<float>()(C,1) ); return 0;
}

static int _sgs_method__UIFrame__doKeyPress( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, doKeyPress ) ) return 0;
	data->doKeyPress( sgs_GetVar<int>()(C,0), sgs_GetVar<bool>()(C,1) ); return 0;
}

static int _sgs_method__UIFrame__doPutChar( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, doPutChar ) ) return 0;
	data->doPutChar( sgs_GetVar<int>()(C,0) ); return 0;
}

static int _sgs_method__UIFrame__setTimeout( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, setTimeout ) ) return 0;
	sgs_PushVar(C,data->setTimeout( sgs_GetVar<float>()(C,0), sgs_GetVar<sgsVariable>()(C,1) )); return 1;
}

static int _sgs_method__UIFrame__setInterval( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, setInterval ) ) return 0;
	sgs_PushVar(C,data->setInterval( sgs_GetVar<float>()(C,0), sgs_GetVar<sgsVariable>()(C,1) )); return 1;
}

static int _sgs_method__UIFrame__clearTimeout( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, clearTimeout ) ) return 0;
	data->clearTimeout( sgs_GetVar<int64_t>()(C,0) ); return 0;
}

static int _sgs_method__UIFrame__clearInterval( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, clearInterval ) ) return 0;
	data->clearInterval( sgs_GetVar<int64_t>()(C,0) ); return 0;
}

static int _sgs_method__UIFrame__processTimers( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, processTimers ) ) return 0;
	data->processTimers( sgs_GetVar<float>()(C,0) ); return 0;
}

static int _sgs_method__UIFrame__pushScissorRect( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, pushScissorRect ) ) return 0;
	sgs_PushVar(C,data->pushScissorRect( sgs_GetVar<float>()(C,0), sgs_GetVar<float>()(C,1), sgs_GetVar<float>()(C,2), sgs_GetVar<float>()(C,3) )); return 1;
}

static int _sgs_method__UIFrame__pushScissorRectUnclipped( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, pushScissorRectUnclipped ) ) return 0;
	sgs_PushVar(C,data->pushScissorRectUnclipped( sgs_GetVar<float>()(C,0), sgs_GetVar<float>()(C,1), sgs_GetVar<float>()(C,2), sgs_GetVar<float>()(C,3) )); return 1;
}

static int _sgs_method__UIFrame__popScissorRect( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, popScissorRect ) ) return 0;
	sgs_PushVar(C,data->popScissorRect(  )); return 1;
}

static int _sgs_method__UIFrame__getScissorRectCount( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, getScissorRectCount ) ) return 0;
	sgs_PushVar(C,data->getScissorRectCount(  )); return 1;
}

static int _sgs_method__UIFrame__addStyleSheet( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, addStyleSheet ) ) return 0;
	data->addStyleSheet( sgs_GetVar<UIStyleSheet::Handle>()(C,0) ); return 0;
}

static int _sgs_method__UIFrame__removeStyleSheet( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, removeStyleSheet ) ) return 0;
	data->removeStyleSheet( sgs_GetVar<UIStyleSheet::Handle>()(C,0) ); return 0;
}

static int _sgs_method__UIFrame__getStyleSheets( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, getStyleSheets ) ) return 0;
	sgs_PushVar(C,data->getStyleSheets(  )); return 1;
}

static int _sgs_method__UIFrame__getStyleSheet( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, getStyleSheet ) ) return 0;
	sgs_PushVar(C,data->getStyleSheet( sgs_GetVar<size_t>()(C,0) )); return 1;
}

static int _sgs_method__UIFrame__getStyleSheetCount( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, getStyleSheetCount ) ) return 0;
	sgs_PushVar(C,data->getStyleSheetCount(  )); return 1;
}

static int _sgs_method__UIFrame__getClickOffsetX( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, getClickOffsetX ) ) return 0;
	sgs_PushVar(C,data->getClickOffsetX( sgs_GetVar<int>()(C,0) )); return 1;
}

static int _sgs_method__UIFrame__getClickOffsetY( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, getClickOffsetY ) ) return 0;
	sgs_PushVar(C,data->getClickOffsetY( sgs_GetVar<int>()(C,0) )); return 1;
}

static int _sgs_method__UIFrame__getHoverControl( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, getHoverControl ) ) return 0;
	sgs_PushVar(C,data->getHoverControl(  )); return 1;
}

static int _sgs_method__UIFrame__getFocusControl( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, getFocusControl ) ) return 0;
	sgs_PushVar(C,data->getFocusControl(  )); return 1;
}

static int _sgs_method__UIFrame__getControlUnderCursor( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, getControlUnderCursor ) ) return 0;
	sgs_PushVar(C,data->getControlUnderCursor(  )); return 1;
}

static int _sgs_method__UIFrame__getControlUnderPoint( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, getControlUnderPoint ) ) return 0;
	sgs_PushVar(C,data->getControlUnderPoint( sgs_GetVar<float>()(C,0), sgs_GetVar<float>()(C,1) )); return 1;
}

static int _sgs_method__UIFrame__isControlUnderCursor( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, isControlUnderCursor ) ) return 0;
	sgs_PushVar(C,data->isControlUnderCursor( sgs_GetVar<sgsHandle< UIControl > >()(C,0) )); return 1;
}

static int _sgs_method__UIFrame__isControlUnderPoint( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, isControlUnderPoint ) ) return 0;
	sgs_PushVar(C,data->isControlUnderPoint( sgs_GetVar<sgsHandle< UIControl > >()(C,0), sgs_GetVar<float>()(C,1), sgs_GetVar<float>()(C,2) )); return 1;
}

static int _sgs_method__UIFrame__setTheme( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, setTheme ) ) return 0;
	data->setTheme( sgs_GetVar<sgsVariable>()(C,0) ); return 0;
}

static int _sgs_method__UIFrame__resize( SGS_CTX )
{
	UIFrame* data; if( !SGS_PARSE_METHOD( C, UIFrame::_sgs_interface, data, UIFrame, resize ) ) return 0;
	data->resize( sgs_GetVar<float>()(C,0), sgs_GetVar<float>()(C,1) ); return 0;
}

int UIFrame::_sgs_destruct( SGS_CTX, sgs_VarObj* obj )
{
	static_cast<UIFrame*>( obj->data )->~UIFrame();
	return SGS_SUCCESS;
}

int UIFrame::_sgs_gcmark( SGS_CTX, sgs_VarObj* obj )
{
	return SGS_SUCCESS;
}

int UIFrame::_sgs_getindex( SGS_ARGS_GETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "createControl" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__createControl ); return SGS_SUCCESS; }
		SGS_CASE( "find" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__find ); return SGS_SUCCESS; }
		SGS_CASE( "event" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__event ); return SGS_SUCCESS; }
		SGS_CASE( "render" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__render ); return SGS_SUCCESS; }
		SGS_CASE( "handleMouseMove" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__handleMouseMove ); return SGS_SUCCESS; }
		SGS_CASE( "setFocus" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__setFocus ); return SGS_SUCCESS; }
		SGS_CASE( "doMouseMove" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__doMouseMove ); return SGS_SUCCESS; }
		SGS_CASE( "doMouseButton" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__doMouseButton ); return SGS_SUCCESS; }
		SGS_CASE( "doMouseWheel" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__doMouseWheel ); return SGS_SUCCESS; }
		SGS_CASE( "doKeyPress" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__doKeyPress ); return SGS_SUCCESS; }
		SGS_CASE( "doPutChar" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__doPutChar ); return SGS_SUCCESS; }
		SGS_CASE( "setTimeout" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__setTimeout ); return SGS_SUCCESS; }
		SGS_CASE( "setInterval" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__setInterval ); return SGS_SUCCESS; }
		SGS_CASE( "clearTimeout" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__clearTimeout ); return SGS_SUCCESS; }
		SGS_CASE( "clearInterval" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__clearInterval ); return SGS_SUCCESS; }
		SGS_CASE( "processTimers" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__processTimers ); return SGS_SUCCESS; }
		SGS_CASE( "pushScissorRect" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__pushScissorRect ); return SGS_SUCCESS; }
		SGS_CASE( "pushScissorRectUnclipped" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__pushScissorRectUnclipped ); return SGS_SUCCESS; }
		SGS_CASE( "popScissorRect" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__popScissorRect ); return SGS_SUCCESS; }
		SGS_CASE( "getScissorRectCount" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__getScissorRectCount ); return SGS_SUCCESS; }
		SGS_CASE( "addStyleSheet" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__addStyleSheet ); return SGS_SUCCESS; }
		SGS_CASE( "removeStyleSheet" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__removeStyleSheet ); return SGS_SUCCESS; }
		SGS_CASE( "getStyleSheets" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__getStyleSheets ); return SGS_SUCCESS; }
		SGS_CASE( "getStyleSheet" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__getStyleSheet ); return SGS_SUCCESS; }
		SGS_CASE( "getStyleSheetCount" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__getStyleSheetCount ); return SGS_SUCCESS; }
		SGS_CASE( "getClickOffsetX" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__getClickOffsetX ); return SGS_SUCCESS; }
		SGS_CASE( "getClickOffsetY" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__getClickOffsetY ); return SGS_SUCCESS; }
		SGS_CASE( "getHoverControl" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__getHoverControl ); return SGS_SUCCESS; }
		SGS_CASE( "getFocusControl" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__getFocusControl ); return SGS_SUCCESS; }
		SGS_CASE( "getControlUnderCursor" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__getControlUnderCursor ); return SGS_SUCCESS; }
		SGS_CASE( "getControlUnderPoint" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__getControlUnderPoint ); return SGS_SUCCESS; }
		SGS_CASE( "isControlUnderCursor" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__isControlUnderCursor ); return SGS_SUCCESS; }
		SGS_CASE( "isControlUnderPoint" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__isControlUnderPoint ); return SGS_SUCCESS; }
		SGS_CASE( "scissor_func" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->scissor_func ); return SGS_SUCCESS; }
		SGS_CASE( "clipboard_func" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->clipboard_func ); return SGS_SUCCESS; }
		SGS_CASE( "cursor_func" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->cursor_func ); return SGS_SUCCESS; }
		SGS_CASE( "font_func" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->font_func ); return SGS_SUCCESS; }
		SGS_CASE( "image_func" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->image_func ); return SGS_SUCCESS; }
		SGS_CASE( "icon_func" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->icon_func ); return SGS_SUCCESS; }
		SGS_CASE( "theme" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->theme ); return SGS_SUCCESS; }
		SGS_CASE( "setTheme" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__setTheme ); return SGS_SUCCESS; }
		SGS_CASE( "clickTime" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->clickTime ); return SGS_SUCCESS; }
		SGS_CASE( "x" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->x ); return SGS_SUCCESS; }
		SGS_CASE( "y" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->y ); return SGS_SUCCESS; }
		SGS_CASE( "width" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->width ); return SGS_SUCCESS; }
		SGS_CASE( "height" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->height ); return SGS_SUCCESS; }
		SGS_CASE( "resize" ){ sgs_PushCFunction( C, _sgs_method__UIFrame__resize ); return SGS_SUCCESS; }
		SGS_CASE( "root" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->root ); return SGS_SUCCESS; }
		SGS_CASE( "mouseX" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->mouseX ); return SGS_SUCCESS; }
		SGS_CASE( "mouseY" ){ sgs_PushVar( C, static_cast<UIFrame*>( obj->data )->mouseY ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIFrame::_sgs_setindex( SGS_ARGS_SETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "scissor_func" ){ static_cast<UIFrame*>( obj->data )->scissor_func = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "clipboard_func" ){ static_cast<UIFrame*>( obj->data )->clipboard_func = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "cursor_func" ){ static_cast<UIFrame*>( obj->data )->cursor_func = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "font_func" ){ static_cast<UIFrame*>( obj->data )->font_func = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "image_func" ){ static_cast<UIFrame*>( obj->data )->image_func = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "icon_func" ){ static_cast<UIFrame*>( obj->data )->icon_func = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "clickTime" ){ static_cast<UIFrame*>( obj->data )->clickTime = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "x" ){ static_cast<UIFrame*>( obj->data )->x = sgs_GetVarP<float>()( C, val );
			static_cast<UIFrame*>( obj->data )->onLayoutChange(); return SGS_SUCCESS; }
		SGS_CASE( "y" ){ static_cast<UIFrame*>( obj->data )->y = sgs_GetVarP<float>()( C, val );
			static_cast<UIFrame*>( obj->data )->onLayoutChange(); return SGS_SUCCESS; }
		SGS_CASE( "width" ){ static_cast<UIFrame*>( obj->data )->width = sgs_GetVarP<float>()( C, val );
			static_cast<UIFrame*>( obj->data )->onLayoutChange(); return SGS_SUCCESS; }
		SGS_CASE( "height" ){ static_cast<UIFrame*>( obj->data )->height = sgs_GetVarP<float>()( C, val );
			static_cast<UIFrame*>( obj->data )->onLayoutChange(); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIFrame::_sgs_dump( SGS_CTX, sgs_VarObj* obj, int depth )
{
	char bfr[ 39 ];
	sprintf( bfr, "UIFrame (%p) %s", obj->data, depth > 0 ? "\n{" : " ..." );
	sgs_PushString( C, bfr );
	if( depth > 0 )
	{
		{ sgs_PushString( C, "\nscissor_func = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->scissor_func, depth ).push( C ); }
		{ sgs_PushString( C, "\nclipboard_func = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->clipboard_func, depth ).push( C ); }
		{ sgs_PushString( C, "\ncursor_func = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->cursor_func, depth ).push( C ); }
		{ sgs_PushString( C, "\nfont_func = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->font_func, depth ).push( C ); }
		{ sgs_PushString( C, "\nimage_func = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->image_func, depth ).push( C ); }
		{ sgs_PushString( C, "\nicon_func = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->icon_func, depth ).push( C ); }
		{ sgs_PushString( C, "\ntheme = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->theme, depth ).push( C ); }
		{ sgs_PushString( C, "\nclickTime = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->clickTime, depth ).push( C ); }
		{ sgs_PushString( C, "\nx = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->x, depth ).push( C ); }
		{ sgs_PushString( C, "\ny = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->y, depth ).push( C ); }
		{ sgs_PushString( C, "\nwidth = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->width, depth ).push( C ); }
		{ sgs_PushString( C, "\nheight = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->height, depth ).push( C ); }
		{ sgs_PushString( C, "\nroot = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->root, depth ).push( C ); }
		{ sgs_PushString( C, "\nmouseX = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->mouseX, depth ).push( C ); }
		{ sgs_PushString( C, "\nmouseY = " ); sgs_DumpData( C, static_cast<UIFrame*>( obj->data )->mouseY, depth ).push( C ); }
		sgs_StringConcat( C, 30 );
		sgs_PadString( C );
		sgs_PushString( C, "\n}" );
		sgs_StringConcat( C, 3 );
	}
	return SGS_SUCCESS;
}

sgs_ObjInterface UIFrame::_sgs_interface[1] =
{{
	"UIFrame",
	UIFrame::_sgs_destruct, UIFrame::sgs_gcmark, UIFrame::_sgs_getindex, UIFrame::_sgs_setindex, NULL, NULL, UIFrame::_sgs_dump, NULL, NULL, NULL, 
}};


int UIComponent::_sgs_destruct( SGS_CTX, sgs_VarObj* obj )
{
	static_cast<UIComponent*>( obj->data )->~UIComponent();
	return SGS_SUCCESS;
}

int UIComponent::_sgs_gcmark( SGS_CTX, sgs_VarObj* obj )
{
	return SGS_SUCCESS;
}

int UIComponent::_sgs_getindex( SGS_ARGS_GETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "type" ){ sgs_PushVar( C, static_cast<UIComponent*>( obj->data )->type ); return SGS_SUCCESS; }
		SGS_CASE( "func" ){ sgs_PushVar( C, static_cast<UIComponent*>( obj->data )->func ); return SGS_SUCCESS; }
		SGS_CASE( "data" ){ sgs_PushVar( C, static_cast<UIComponent*>( obj->data )->data ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIComponent::_sgs_setindex( SGS_ARGS_SETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "type" ){ static_cast<UIComponent*>( obj->data )->type = sgs_GetVarP<sgsString>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "func" ){ static_cast<UIComponent*>( obj->data )->func = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "data" ){ static_cast<UIComponent*>( obj->data )->data = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIComponent::_sgs_dump( SGS_CTX, sgs_VarObj* obj, int depth )
{
	char bfr[ 43 ];
	sprintf( bfr, "UIComponent (%p) %s", obj->data, depth > 0 ? "\n{" : " ..." );
	sgs_PushString( C, bfr );
	if( depth > 0 )
	{
		{ sgs_PushString( C, "\ntype = " ); sgs_DumpData( C, static_cast<UIComponent*>( obj->data )->type, depth ).push( C ); }
		{ sgs_PushString( C, "\nfunc = " ); sgs_DumpData( C, static_cast<UIComponent*>( obj->data )->func, depth ).push( C ); }
		{ sgs_PushString( C, "\ndata = " ); sgs_DumpData( C, static_cast<UIComponent*>( obj->data )->data, depth ).push( C ); }
		sgs_StringConcat( C, 6 );
		sgs_PadString( C );
		sgs_PushString( C, "\n}" );
		sgs_StringConcat( C, 3 );
	}
	return SGS_SUCCESS;
}

sgs_ObjInterface UIComponent::_sgs_interface[1] =
{{
	"UIComponent",
	UIComponent::_sgs_destruct, UIComponent::_sgs_gcmark, UIComponent::_sgs_getindex, UIComponent::_sgs_setindex, NULL, NULL, UIComponent::_sgs_dump, NULL, NULL, NULL, 
}};


static int _sgs_method__UIControl__updateScroll( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, updateScroll ) ) return 0;
	data->updateScroll(  ); return 0;
}

static int _sgs_method__UIControl__updateTheme( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, updateTheme ) ) return 0;
	data->updateTheme(  ); return 0;
}

static int _sgs_method__UIControl__onLayoutChange( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, onLayoutChange ) ) return 0;
	data->onLayoutChange(  ); return 0;
}

static int _sgs_method__UIControl__insertChild( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, insertChild ) ) return 0;
	sgs_PushVar(C,data->insertChild( sgs_GetVar<UIControl::Handle>()(C,0), sgs_GetVar<ssize_t>()(C,1) )); return 1;
}

static int _sgs_method__UIControl__removeChild( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, removeChild ) ) return 0;
	sgs_PushVar(C,data->removeChild( sgs_GetVar<UIControl::Handle>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__removeAllChildren( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, removeAllChildren ) ) return 0;
	sgs_PushVar(C,data->removeAllChildren(  )); return 1;
}

static int _sgs_method__UIControl__detach( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, detach ) ) return 0;
	data->detach(  ); return 0;
}

static int _sgs_method__UIControl__destroy( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, destroy ) ) return 0;
	data->destroy( sgs_GetVar<bool>()(C,0) ); return 0;
}

static int _sgs_method__UIControl__destroyAllChildren( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, destroyAllChildren ) ) return 0;
	data->destroyAllChildren( sgs_GetVar<bool>()(C,0), sgs_GetVar<int>()(C,1) ); return 0;
}

static int _sgs_method__UIControl__swapChild( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, swapChild ) ) return 0;
	sgs_PushVar(C,data->swapChild( sgs_GetVar<UIControl::Handle>()(C,0), sgs_GetVar<UIControl::Handle>()(C,1) )); return 1;
}

static int _sgs_method__UIControl__findChild( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, findChild ) ) return 0;
	sgs_PushVar(C,data->findChild( sgs_GetVar<sgsString>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__children( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, children ) ) return 0;
	sgs_PushVar(C,data->children( sgs_GetVar<bool>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__allChildren( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, allChildren ) ) return 0;
	sgs_PushVar(C,data->allChildren(  )); return 1;
}

static int _sgs_method__UIControl__sortChildren( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, sortChildren ) ) return 0;
	data->sortChildren(  ); return 0;
}

static int _sgs_method__UIControl__sortSiblings( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, sortSiblings ) ) return 0;
	data->sortSiblings(  ); return 0;
}

static int _sgs_method__UIControl__getChildIndex( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, getChildIndex ) ) return 0;
	sgs_PushVar(C,data->getChildIndex( sgs_GetVar<UIControl::Handle>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__getChildCount( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, getChildCount ) ) return 0;
	sgs_PushVar(C,data->getChildCount( sgs_GetVar<bool>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__prependChild( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, prependChild ) ) return 0;
	sgs_PushVar(C,data->prependChild( sgs_GetVar<UIControl::Handle>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__appendChild( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, appendChild ) ) return 0;
	sgs_PushVar(C,data->appendChild( sgs_GetVar<UIControl::Handle>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__addChild( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, addChild ) ) return 0;
	sgs_PushVar(C,data->addChild( sgs_GetVar<UIControl::Handle>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__getOrderIndex( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, getOrderIndex ) ) return 0;
	sgs_PushVar(C,data->getOrderIndex(  )); return 1;
}

static int _sgs_method__UIControl__getAllChildCount( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, getAllChildCount ) ) return 0;
	sgs_PushVar(C,data->getAllChildCount(  )); return 1;
}

static int _sgs_method__UIControl__moveUp( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, moveUp ) ) return 0;
	sgs_PushVar(C,data->moveUp(  )); return 1;
}

static int _sgs_method__UIControl__moveDown( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, moveDown ) ) return 0;
	sgs_PushVar(C,data->moveDown(  )); return 1;
}

static int _sgs_method__UIControl__moveToIndex( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, moveToIndex ) ) return 0;
	sgs_PushVar(C,data->moveToIndex( sgs_GetVar<int>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__swapOutFor( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, swapOutFor ) ) return 0;
	sgs_PushVar(C,data->swapOutFor( sgs_GetVar<UIControl::Handle>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__getChildAABB( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, getChildAABB ) ) return 0;
	return data->getChildAABB( sgs_GetVar<int>()(C,0) );
}

static int _sgs_method__UIControl__setAnchorRect( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, setAnchorRect ) ) return 0;
	data->setAnchorRect( sgs_GetVar<float>()(C,0), sgs_GetVar<float>()(C,1), sgs_GetVar<float>()(C,2), sgs_GetVar<float>()(C,3) ); return 0;
}

static int _sgs_method__UIControl__getPrev( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, getPrev ) ) return 0;
	sgs_PushVar(C,data->getPrev(  )); return 1;
}

static int _sgs_method__UIControl__getNext( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, getNext ) ) return 0;
	sgs_PushVar(C,data->getNext(  )); return 1;
}

static int _sgs_method__UIControl__hasEventBinding( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, hasEventBinding ) ) return 0;
	sgs_PushVar(C,data->hasEventBinding( sgs_GetVar<sgsString>()(C,0), sgs_GetVar<sgsVariable>()(C,1) )); return 1;
}

static int _sgs_method__UIControl__bindEvent( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, bindEvent ) ) return 0;
	sgs_PushVar(C,data->bindEvent( sgs_GetVar<sgsString>()(C,0), sgs_GetVar<sgsVariable>()(C,1) )); return 1;
}

static int _sgs_method__UIControl__unbindEvent( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, unbindEvent ) ) return 0;
	sgs_PushVar(C,data->unbindEvent( sgs_GetVar<sgsString>()(C,0), sgs_GetVar<sgsVariable>()(C,1) )); return 1;
}

static int _sgs_method__UIControl__unbindEventAll( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, unbindEventAll ) ) return 0;
	sgs_PushVar(C,data->unbindEventAll( sgs_GetVar<sgsString>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__unbindEverything( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, unbindEverything ) ) return 0;
	data->unbindEverything(  ); return 0;
}

static int _sgs_method__UIControl__callEvent( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, callEvent ) ) return 0;
	sgs_PushVar(C,data->callEvent( sgs_GetVar<sgsString>()(C,0), sgs_GetVar<sgsVariable>()(C,1) )); return 1;
}

static int _sgs_method__UIControl__addComponent( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, addComponent ) ) return 0;
	data->addComponent( sgs_GetVar<sgsString>()(C,0), sgs_GetVar<sgsVariable>()(C,1), sgs_GetVar<sgsVariable>()(C,2) ); return 0;
}

static int _sgs_method__UIControl__getComponentCount( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, getComponentCount ) ) return 0;
	sgs_PushVar(C,data->getComponentCount(  )); return 1;
}

static int _sgs_method__UIControl__getComponent( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, getComponent ) ) return 0;
	sgs_PushVar(C,data->getComponent( sgs_GetVar<int>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__findComponentByType( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, findComponentByType ) ) return 0;
	sgs_PushVar(C,data->findComponentByType( sgs_GetVar<sgsString>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__removeComponentByType( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, removeComponentByType ) ) return 0;
	sgs_PushVar(C,data->removeComponentByType( sgs_GetVar<sgsString>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__removeComponentAtIndex( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, removeComponentAtIndex ) ) return 0;
	sgs_PushVar(C,data->removeComponentAtIndex( sgs_GetVar<int>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__animate( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, animate ) ) return 0;
	sgs_PushVar(C,data->animate( sgs_GetVar<sgsVariable>()(C,0), sgs_GetVar<float>()(C,1), sgs_GetVar<sgsVariable>()(C,2), sgs_GetVar<sgsVariable>()(C,3) )); return 1;
}

static int _sgs_method__UIControl__stop( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, stop ) ) return 0;
	sgs_PushVar(C,data->stop( sgs_GetVar<bool>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__dequeue( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, dequeue ) ) return 0;
	sgs_PushVar(C,data->dequeue(  )); return 1;
}

static int _sgs_method__UIControl__skip( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, skip ) ) return 0;
	sgs_PushVar(C,data->skip( sgs_GetVar<bool>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__queueSize( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, queueSize ) ) return 0;
	sgs_PushVar(C,data->queueSize(  )); return 1;
}

static int _sgs_method__UIControl__addClass( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, addClass ) ) return 0;
	sgs_PushVar(C,data->addClass( sgs_GetVar<sgsString>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__removeClass( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, removeClass ) ) return 0;
	sgs_PushVar(C,data->removeClass( sgs_GetVar<sgsString>()(C,0) )); return 1;
}

static int _sgs_method__UIControl__addRemClass( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, addRemClass ) ) return 0;
	sgs_PushVar(C,data->addRemClass( sgs_GetVar<sgsString>()(C,0), sgs_GetVar<bool>()(C,1) )); return 1;
}

static int _sgs_method__UIControl__hasClass( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, hasClass ) ) return 0;
	sgs_PushVar(C,data->hasClass( sgs_GetVar<sgsString>()(C,0) )); return 1;
}

static int _sgs_method__UIControl___getMatchedSelectors( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, _getMatchedSelectors ) ) return 0;
	sgs_PushVar(C,data->_getMatchedSelectors(  )); return 1;
}

static int _sgs_method__UIControl__setFont( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, setFont ) ) return 0;
	data->setFont( sgs_GetVar<sgsString>()(C,0), sgs_GetVar<float>()(C,1) ); return 0;
}

static int _sgs_method__UIControl___updateFullRect( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, _updateFullRect ) ) return 0;
	data->_updateFullRect(  ); return 0;
}

static int _sgs_method__UIControl___updateChildRects( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, _updateChildRects ) ) return 0;
	data->_updateChildRects(  ); return 0;
}

static int _sgs_method__UIControl___changedFullRect( SGS_CTX )
{
	UIControl* data; if( !SGS_PARSE_METHOD( C, UIControl::_sgs_interface, data, UIControl, _changedFullRect ) ) return 0;
	data->_changedFullRect(  ); return 0;
}

int UIControl::_sgs_destruct( SGS_CTX, sgs_VarObj* obj )
{
	static_cast<UIControl*>( obj->data )->~UIControl();
	return SGS_SUCCESS;
}

int UIControl::_sgs_gcmark( SGS_CTX, sgs_VarObj* obj )
{
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->parent ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->frame ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->styleParent ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->filteredStyle ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->style ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->_cachedFont ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->_cachedImage ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->_cachedIcon ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->callback ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->data ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->_interface ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->m_children ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->m_events ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->m_components ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIControl*>( obj->data )->m_animQueue ) ) ) return SGS_EINPROC;
	return SGS_SUCCESS;
}

int UIControl::_sgs_getindex( SGS_ARGS_GETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "updateScroll" ){ sgs_PushCFunction( C, _sgs_method__UIControl__updateScroll ); return SGS_SUCCESS; }
		SGS_CASE( "updateTheme" ){ sgs_PushCFunction( C, _sgs_method__UIControl__updateTheme ); return SGS_SUCCESS; }
		SGS_CASE( "onLayoutChange" ){ sgs_PushCFunction( C, _sgs_method__UIControl__onLayoutChange ); return SGS_SUCCESS; }
		SGS_CASE( "insertChild" ){ sgs_PushCFunction( C, _sgs_method__UIControl__insertChild ); return SGS_SUCCESS; }
		SGS_CASE( "removeChild" ){ sgs_PushCFunction( C, _sgs_method__UIControl__removeChild ); return SGS_SUCCESS; }
		SGS_CASE( "removeAllChildren" ){ sgs_PushCFunction( C, _sgs_method__UIControl__removeAllChildren ); return SGS_SUCCESS; }
		SGS_CASE( "detach" ){ sgs_PushCFunction( C, _sgs_method__UIControl__detach ); return SGS_SUCCESS; }
		SGS_CASE( "destroy" ){ sgs_PushCFunction( C, _sgs_method__UIControl__destroy ); return SGS_SUCCESS; }
		SGS_CASE( "destroyAllChildren" ){ sgs_PushCFunction( C, _sgs_method__UIControl__destroyAllChildren ); return SGS_SUCCESS; }
		SGS_CASE( "swapChild" ){ sgs_PushCFunction( C, _sgs_method__UIControl__swapChild ); return SGS_SUCCESS; }
		SGS_CASE( "findChild" ){ sgs_PushCFunction( C, _sgs_method__UIControl__findChild ); return SGS_SUCCESS; }
		SGS_CASE( "children" ){ sgs_PushCFunction( C, _sgs_method__UIControl__children ); return SGS_SUCCESS; }
		SGS_CASE( "allChildren" ){ sgs_PushCFunction( C, _sgs_method__UIControl__allChildren ); return SGS_SUCCESS; }
		SGS_CASE( "sortChildren" ){ sgs_PushCFunction( C, _sgs_method__UIControl__sortChildren ); return SGS_SUCCESS; }
		SGS_CASE( "sortSiblings" ){ sgs_PushCFunction( C, _sgs_method__UIControl__sortSiblings ); return SGS_SUCCESS; }
		SGS_CASE( "getChildIndex" ){ sgs_PushCFunction( C, _sgs_method__UIControl__getChildIndex ); return SGS_SUCCESS; }
		SGS_CASE( "getChildCount" ){ sgs_PushCFunction( C, _sgs_method__UIControl__getChildCount ); return SGS_SUCCESS; }
		SGS_CASE( "prependChild" ){ sgs_PushCFunction( C, _sgs_method__UIControl__prependChild ); return SGS_SUCCESS; }
		SGS_CASE( "appendChild" ){ sgs_PushCFunction( C, _sgs_method__UIControl__appendChild ); return SGS_SUCCESS; }
		SGS_CASE( "addChild" ){ sgs_PushCFunction( C, _sgs_method__UIControl__addChild ); return SGS_SUCCESS; }
		SGS_CASE( "getOrderIndex" ){ sgs_PushCFunction( C, _sgs_method__UIControl__getOrderIndex ); return SGS_SUCCESS; }
		SGS_CASE( "getAllChildCount" ){ sgs_PushCFunction( C, _sgs_method__UIControl__getAllChildCount ); return SGS_SUCCESS; }
		SGS_CASE( "moveUp" ){ sgs_PushCFunction( C, _sgs_method__UIControl__moveUp ); return SGS_SUCCESS; }
		SGS_CASE( "moveDown" ){ sgs_PushCFunction( C, _sgs_method__UIControl__moveDown ); return SGS_SUCCESS; }
		SGS_CASE( "moveToIndex" ){ sgs_PushCFunction( C, _sgs_method__UIControl__moveToIndex ); return SGS_SUCCESS; }
		SGS_CASE( "swapOutFor" ){ sgs_PushCFunction( C, _sgs_method__UIControl__swapOutFor ); return SGS_SUCCESS; }
		SGS_CASE( "getChildAABB" ){ sgs_PushCFunction( C, _sgs_method__UIControl__getChildAABB ); return SGS_SUCCESS; }
		SGS_CASE( "setAnchorRect" ){ sgs_PushCFunction( C, _sgs_method__UIControl__setAnchorRect ); return SGS_SUCCESS; }
		SGS_CASE( "getPrev" ){ sgs_PushCFunction( C, _sgs_method__UIControl__getPrev ); return SGS_SUCCESS; }
		SGS_CASE( "getNext" ){ sgs_PushCFunction( C, _sgs_method__UIControl__getNext ); return SGS_SUCCESS; }
		SGS_CASE( "hasEventBinding" ){ sgs_PushCFunction( C, _sgs_method__UIControl__hasEventBinding ); return SGS_SUCCESS; }
		SGS_CASE( "bindEvent" ){ sgs_PushCFunction( C, _sgs_method__UIControl__bindEvent ); return SGS_SUCCESS; }
		SGS_CASE( "unbindEvent" ){ sgs_PushCFunction( C, _sgs_method__UIControl__unbindEvent ); return SGS_SUCCESS; }
		SGS_CASE( "unbindEventAll" ){ sgs_PushCFunction( C, _sgs_method__UIControl__unbindEventAll ); return SGS_SUCCESS; }
		SGS_CASE( "unbindEverything" ){ sgs_PushCFunction( C, _sgs_method__UIControl__unbindEverything ); return SGS_SUCCESS; }
		SGS_CASE( "callEvent" ){ sgs_PushCFunction( C, _sgs_method__UIControl__callEvent ); return SGS_SUCCESS; }
		SGS_CASE( "addComponent" ){ sgs_PushCFunction( C, _sgs_method__UIControl__addComponent ); return SGS_SUCCESS; }
		SGS_CASE( "getComponentCount" ){ sgs_PushCFunction( C, _sgs_method__UIControl__getComponentCount ); return SGS_SUCCESS; }
		SGS_CASE( "getComponent" ){ sgs_PushCFunction( C, _sgs_method__UIControl__getComponent ); return SGS_SUCCESS; }
		SGS_CASE( "findComponentByType" ){ sgs_PushCFunction( C, _sgs_method__UIControl__findComponentByType ); return SGS_SUCCESS; }
		SGS_CASE( "removeComponentByType" ){ sgs_PushCFunction( C, _sgs_method__UIControl__removeComponentByType ); return SGS_SUCCESS; }
		SGS_CASE( "removeComponentAtIndex" ){ sgs_PushCFunction( C, _sgs_method__UIControl__removeComponentAtIndex ); return SGS_SUCCESS; }
		SGS_CASE( "animate" ){ sgs_PushCFunction( C, _sgs_method__UIControl__animate ); return SGS_SUCCESS; }
		SGS_CASE( "stop" ){ sgs_PushCFunction( C, _sgs_method__UIControl__stop ); return SGS_SUCCESS; }
		SGS_CASE( "dequeue" ){ sgs_PushCFunction( C, _sgs_method__UIControl__dequeue ); return SGS_SUCCESS; }
		SGS_CASE( "skip" ){ sgs_PushCFunction( C, _sgs_method__UIControl__skip ); return SGS_SUCCESS; }
		SGS_CASE( "queueSize" ){ sgs_PushCFunction( C, _sgs_method__UIControl__queueSize ); return SGS_SUCCESS; }
		SGS_CASE( "id" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->id ); return SGS_SUCCESS; }
		SGS_CASE( "name" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->name ); return SGS_SUCCESS; }
		SGS_CASE( "caption" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->caption ); return SGS_SUCCESS; }
		SGS_CASE( "type" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->type ); return SGS_SUCCESS; }
		SGS_CASE( "parent" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->parent ); return SGS_SUCCESS; }
		SGS_CASE( "frame" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->frame ); return SGS_SUCCESS; }
		SGS_CASE( "class" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->classes ); return SGS_SUCCESS; }
		SGS_CASE( "addClass" ){ sgs_PushCFunction( C, _sgs_method__UIControl__addClass ); return SGS_SUCCESS; }
		SGS_CASE( "removeClass" ){ sgs_PushCFunction( C, _sgs_method__UIControl__removeClass ); return SGS_SUCCESS; }
		SGS_CASE( "addRemClass" ){ sgs_PushCFunction( C, _sgs_method__UIControl__addRemClass ); return SGS_SUCCESS; }
		SGS_CASE( "hasClass" ){ sgs_PushCFunction( C, _sgs_method__UIControl__hasClass ); return SGS_SUCCESS; }
		SGS_CASE( "styleParent" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->styleParent ); return SGS_SUCCESS; }
		SGS_CASE( "filteredStyle" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->filteredStyle ); return SGS_SUCCESS; }
		SGS_CASE( "style" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->style ); return SGS_SUCCESS; }
		SGS_CASE( "_getMatchedSelectors" ){ sgs_PushCFunction( C, _sgs_method__UIControl___getMatchedSelectors ); return SGS_SUCCESS; }
		SGS_CASE( "x" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_x() ); return SGS_SUCCESS; }
		SGS_CASE( "y" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_y() ); return SGS_SUCCESS; }
		SGS_CASE( "width" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_width() ); return SGS_SUCCESS; }
		SGS_CASE( "height" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_height() ); return SGS_SUCCESS; }
		SGS_CASE( "q0x" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_q0x() ); return SGS_SUCCESS; }
		SGS_CASE( "q0y" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_q0y() ); return SGS_SUCCESS; }
		SGS_CASE( "q1x" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_q1x() ); return SGS_SUCCESS; }
		SGS_CASE( "q1y" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_q1y() ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientTop" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_nonClientTop() ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientLeft" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_nonClientLeft() ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientRight" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_nonClientRight() ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientBottom" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_nonClientBottom() ); return SGS_SUCCESS; }
		SGS_CASE( "visible" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_visible() ); return SGS_SUCCESS; }
		SGS_CASE( "index" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_index() ); return SGS_SUCCESS; }
		SGS_CASE( "topmost" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_topmost() ); return SGS_SUCCESS; }
		SGS_CASE( "minWidth" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_minWidth() ); return SGS_SUCCESS; }
		SGS_CASE( "maxWidth" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_maxWidth() ); return SGS_SUCCESS; }
		SGS_CASE( "minHeight" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_minHeight() ); return SGS_SUCCESS; }
		SGS_CASE( "maxHeight" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_maxHeight() ); return SGS_SUCCESS; }
		SGS_CASE( "marginLeft" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_marginLeft() ); return SGS_SUCCESS; }
		SGS_CASE( "marginRight" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_marginRight() ); return SGS_SUCCESS; }
		SGS_CASE( "marginTop" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_marginTop() ); return SGS_SUCCESS; }
		SGS_CASE( "marginBottom" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_marginBottom() ); return SGS_SUCCESS; }
		SGS_CASE( "paddingLeft" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_paddingLeft() ); return SGS_SUCCESS; }
		SGS_CASE( "paddingRight" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_paddingRight() ); return SGS_SUCCESS; }
		SGS_CASE( "paddingTop" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_paddingTop() ); return SGS_SUCCESS; }
		SGS_CASE( "paddingBottom" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_paddingBottom() ); return SGS_SUCCESS; }
		SGS_CASE( "posMode" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_posMode() ); return SGS_SUCCESS; }
		SGS_CASE( "stackMode" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_stackMode() ); return SGS_SUCCESS; }
		SGS_CASE( "overflow" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_overflow() ); return SGS_SUCCESS; }
		SGS_CASE( "backgroundColor" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_backgroundColor() ); return SGS_SUCCESS; }
		SGS_CASE( "textColor" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_textColor() ); return SGS_SUCCESS; }
		SGS_CASE( "halign" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_halign() ); return SGS_SUCCESS; }
		SGS_CASE( "valign" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_valign() ); return SGS_SUCCESS; }
		SGS_CASE( "cursor" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_cursor() ); return SGS_SUCCESS; }
		SGS_CASE( "font" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_font() ); return SGS_SUCCESS; }
		SGS_CASE( "image" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_image() ); return SGS_SUCCESS; }
		SGS_CASE( "icon" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_icon() ); return SGS_SUCCESS; }
		SGS_CASE( "fontSize" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_fontSize() ); return SGS_SUCCESS; }
		SGS_CASE( "renderfunc" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_renderfunc() ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientH" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_nonClientH() ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientV" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_nonClientV() ); return SGS_SUCCESS; }
		SGS_CASE( "nonClient" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_nonClient() ); return SGS_SUCCESS; }
		SGS_CASE( "marginH" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_marginH() ); return SGS_SUCCESS; }
		SGS_CASE( "marginV" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_marginV() ); return SGS_SUCCESS; }
		SGS_CASE( "margin" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_margin() ); return SGS_SUCCESS; }
		SGS_CASE( "paddingH" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_paddingH() ); return SGS_SUCCESS; }
		SGS_CASE( "paddingV" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_paddingV() ); return SGS_SUCCESS; }
		SGS_CASE( "padding" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_padding() ); return SGS_SUCCESS; }
		SGS_CASE( "anchorMode" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_anchorMode() ); return SGS_SUCCESS; }
		SGS_CASE( "align" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_align() ); return SGS_SUCCESS; }
		SGS_CASE( "scroll_x" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->scroll_x ); return SGS_SUCCESS; }
		SGS_CASE( "scroll_y" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->scroll_y ); return SGS_SUCCESS; }
		SGS_CASE( "nonclient" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->nonclient ); return SGS_SUCCESS; }
		SGS_CASE( "offsetLeft" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_offsetLeft() ); return SGS_SUCCESS; }
		SGS_CASE( "offsetRight" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_offsetRight() ); return SGS_SUCCESS; }
		SGS_CASE( "offsetTop" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_offsetTop() ); return SGS_SUCCESS; }
		SGS_CASE( "offsetBottom" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_offsetBottom() ); return SGS_SUCCESS; }
		SGS_CASE( "_cachedFont" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->_cachedFont ); return SGS_SUCCESS; }
		SGS_CASE( "setFont" ){ sgs_PushCFunction( C, _sgs_method__UIControl__setFont ); return SGS_SUCCESS; }
		SGS_CASE( "_cachedImage" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->_cachedImage ); return SGS_SUCCESS; }
		SGS_CASE( "_cachedIcon" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->_cachedIcon ); return SGS_SUCCESS; }
		SGS_CASE( "callback" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->callback ); return SGS_SUCCESS; }
		SGS_CASE( "data" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->data ); return SGS_SUCCESS; }
		SGS_CASE( "_interface" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->_interface ); return SGS_SUCCESS; }
		SGS_CASE( "autoWidth" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->autoWidth ); return SGS_SUCCESS; }
		SGS_CASE( "autoHeight" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->autoHeight ); return SGS_SUCCESS; }
		SGS_CASE( "rx0" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->rx0 ); return SGS_SUCCESS; }
		SGS_CASE( "rx1" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->rx1 ); return SGS_SUCCESS; }
		SGS_CASE( "ry0" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->ry0 ); return SGS_SUCCESS; }
		SGS_CASE( "ry1" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->ry1 ); return SGS_SUCCESS; }
		SGS_CASE( "realWidth" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_realWidth() ); return SGS_SUCCESS; }
		SGS_CASE( "realHeight" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_realHeight() ); return SGS_SUCCESS; }
		SGS_CASE( "cx0" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->cx0 ); return SGS_SUCCESS; }
		SGS_CASE( "cx1" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->cx1 ); return SGS_SUCCESS; }
		SGS_CASE( "cy0" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->cy0 ); return SGS_SUCCESS; }
		SGS_CASE( "cy1" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->cy1 ); return SGS_SUCCESS; }
		SGS_CASE( "clientWidth" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_clientWidth() ); return SGS_SUCCESS; }
		SGS_CASE( "clientHeight" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_clientHeight() ); return SGS_SUCCESS; }
		SGS_CASE( "px0" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->px0 ); return SGS_SUCCESS; }
		SGS_CASE( "px1" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->px1 ); return SGS_SUCCESS; }
		SGS_CASE( "py0" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->py0 ); return SGS_SUCCESS; }
		SGS_CASE( "py1" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->py1 ); return SGS_SUCCESS; }
		SGS_CASE( "paddedWidth" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_paddedWidth() ); return SGS_SUCCESS; }
		SGS_CASE( "paddedHeight" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->get_paddedHeight() ); return SGS_SUCCESS; }
		SGS_CASE( "_updateFullRect" ){ sgs_PushCFunction( C, _sgs_method__UIControl___updateFullRect ); return SGS_SUCCESS; }
		SGS_CASE( "_updateChildRects" ){ sgs_PushCFunction( C, _sgs_method__UIControl___updateChildRects ); return SGS_SUCCESS; }
		SGS_CASE( "_changedFullRect" ){ sgs_PushCFunction( C, _sgs_method__UIControl___changedFullRect ); return SGS_SUCCESS; }
		SGS_CASE( "_updatingLayout" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->_updatingLayout ); return SGS_SUCCESS; }
		SGS_CASE( "_roundedCoords" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->_roundedCoords ); return SGS_SUCCESS; }
		SGS_CASE( "_childAffectsLayout" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->_childAffectsLayout ); return SGS_SUCCESS; }
		SGS_CASE( "_clientRectFromPadded" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->_clientRectFromPadded ); return SGS_SUCCESS; }
		SGS_CASE( "_neverHit" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->_neverHit ); return SGS_SUCCESS; }
		SGS_CASE( "_layoutRectOverride" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->_layoutRectOverride ); return SGS_SUCCESS; }
		SGS_CASE( "_disableClickBubbling" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->_disableClickBubbling ); return SGS_SUCCESS; }
		SGS_CASE( "mouseOn" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->mouseOn ); return SGS_SUCCESS; }
		SGS_CASE( "keyboardFocus" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->keyboardFocus ); return SGS_SUCCESS; }
		SGS_CASE( "clicked" ){ sgs_PushVar( C, static_cast<UIControl*>( obj->data )->clicked ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIControl::_sgs_setindex( SGS_ARGS_SETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "name" ){ static_cast<UIControl*>( obj->data )->name = sgs_GetVarP<sgsString>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "caption" ){ static_cast<UIControl*>( obj->data )->caption = sgs_GetVarP<sgsString>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "type" ){ static_cast<UIControl*>( obj->data )->type = sgs_GetVarP<sgsString>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "class" ){ static_cast<UIControl*>( obj->data )->classes = sgs_GetVarP<sgsString>()( C, val );
			static_cast<UIControl*>( obj->data )->_classUpdated(); return SGS_SUCCESS; }
		SGS_CASE( "styleParent" ){ static_cast<UIControl*>( obj->data )->styleParent = sgs_GetVarP<Handle>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "style" ){ static_cast<UIControl*>( obj->data )->style = sgs_GetVarP<UIStyle>()( C, val );
			static_cast<UIControl*>( obj->data )->_remergeStyle(); return SGS_SUCCESS; }
		SGS_CASE( "x" ){ static_cast<UIControl*>( obj->data )->set_x( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "y" ){ static_cast<UIControl*>( obj->data )->set_y( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "width" ){ static_cast<UIControl*>( obj->data )->set_width( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "height" ){ static_cast<UIControl*>( obj->data )->set_height( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "q0x" ){ static_cast<UIControl*>( obj->data )->set_q0x( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "q0y" ){ static_cast<UIControl*>( obj->data )->set_q0y( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "q1x" ){ static_cast<UIControl*>( obj->data )->set_q1x( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "q1y" ){ static_cast<UIControl*>( obj->data )->set_q1y( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientTop" ){ static_cast<UIControl*>( obj->data )->set_nonClientTop( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientLeft" ){ static_cast<UIControl*>( obj->data )->set_nonClientLeft( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientRight" ){ static_cast<UIControl*>( obj->data )->set_nonClientRight( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientBottom" ){ static_cast<UIControl*>( obj->data )->set_nonClientBottom( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "visible" ){ static_cast<UIControl*>( obj->data )->set_visible( sgs_GetVarP<sgsMaybe<bool> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "index" ){ static_cast<UIControl*>( obj->data )->set_index( sgs_GetVarP<sgsMaybe<int> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "topmost" ){ static_cast<UIControl*>( obj->data )->set_topmost( sgs_GetVarP<sgsMaybe<bool> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "minWidth" ){ static_cast<UIControl*>( obj->data )->set_minWidth( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "maxWidth" ){ static_cast<UIControl*>( obj->data )->set_maxWidth( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "minHeight" ){ static_cast<UIControl*>( obj->data )->set_minHeight( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "maxHeight" ){ static_cast<UIControl*>( obj->data )->set_maxHeight( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "marginLeft" ){ static_cast<UIControl*>( obj->data )->set_marginLeft( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "marginRight" ){ static_cast<UIControl*>( obj->data )->set_marginRight( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "marginTop" ){ static_cast<UIControl*>( obj->data )->set_marginTop( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "marginBottom" ){ static_cast<UIControl*>( obj->data )->set_marginBottom( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "paddingLeft" ){ static_cast<UIControl*>( obj->data )->set_paddingLeft( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "paddingRight" ){ static_cast<UIControl*>( obj->data )->set_paddingRight( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "paddingTop" ){ static_cast<UIControl*>( obj->data )->set_paddingTop( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "paddingBottom" ){ static_cast<UIControl*>( obj->data )->set_paddingBottom( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "posMode" ){ static_cast<UIControl*>( obj->data )->set_posMode( sgs_GetVarP<sgsMaybe<int8_t> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "stackMode" ){ static_cast<UIControl*>( obj->data )->set_stackMode( sgs_GetVarP<sgsMaybe<int8_t> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "overflow" ){ static_cast<UIControl*>( obj->data )->set_overflow( sgs_GetVarP<sgsMaybe<bool> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "backgroundColor" ){ static_cast<UIControl*>( obj->data )->set_backgroundColor( sgs_GetVarP<sgsMaybe<UIColor> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "textColor" ){ static_cast<UIControl*>( obj->data )->set_textColor( sgs_GetVarP<sgsMaybe<UIColor> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "halign" ){ static_cast<UIControl*>( obj->data )->set_halign( sgs_GetVarP<sgsMaybe<uint16_t> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "valign" ){ static_cast<UIControl*>( obj->data )->set_valign( sgs_GetVarP<sgsMaybe<uint16_t> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "cursor" ){ static_cast<UIControl*>( obj->data )->set_cursor( sgs_GetVarP<sgsVariable>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "font" ){ static_cast<UIControl*>( obj->data )->set_font( sgs_GetVarP<sgsString>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "image" ){ static_cast<UIControl*>( obj->data )->set_image( sgs_GetVarP<sgsString>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "icon" ){ static_cast<UIControl*>( obj->data )->set_icon( sgs_GetVarP<sgsString>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "fontSize" ){ static_cast<UIControl*>( obj->data )->set_fontSize( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "renderfunc" ){ static_cast<UIControl*>( obj->data )->set_renderfunc( sgs_GetVarP<sgsVariable>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientH" ){ static_cast<UIControl*>( obj->data )->set_nonClientH( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "nonClientV" ){ static_cast<UIControl*>( obj->data )->set_nonClientV( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "nonClient" ){ static_cast<UIControl*>( obj->data )->set_nonClient( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "marginH" ){ static_cast<UIControl*>( obj->data )->set_marginH( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "marginV" ){ static_cast<UIControl*>( obj->data )->set_marginV( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "margin" ){ static_cast<UIControl*>( obj->data )->set_margin( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "paddingH" ){ static_cast<UIControl*>( obj->data )->set_paddingH( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "paddingV" ){ static_cast<UIControl*>( obj->data )->set_paddingV( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "padding" ){ static_cast<UIControl*>( obj->data )->set_padding( sgs_GetVarP<sgsMaybe<float> >()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "anchorMode" ){ static_cast<UIControl*>( obj->data )->set_anchorMode( sgs_GetVarP<int>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "align" ){ static_cast<UIControl*>( obj->data )->set_align( sgs_GetVarP<uint16_t>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "scroll_x" ){ static_cast<UIControl*>( obj->data )->scroll_x = sgs_GetVarP<float>()( C, val );
			static_cast<UIControl*>( obj->data )->updateScroll(); return SGS_SUCCESS; }
		SGS_CASE( "scroll_y" ){ static_cast<UIControl*>( obj->data )->scroll_y = sgs_GetVarP<float>()( C, val );
			static_cast<UIControl*>( obj->data )->updateScroll(); return SGS_SUCCESS; }
		SGS_CASE( "nonclient" ){ static_cast<UIControl*>( obj->data )->nonclient = sgs_GetVarP<bool>()( C, val );
			static_cast<UIControl*>( obj->data )->onLayoutChange(); return SGS_SUCCESS; }
		SGS_CASE( "offsetLeft" ){ static_cast<UIControl*>( obj->data )->set_offsetLeft( sgs_GetVarP<float>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "offsetRight" ){ static_cast<UIControl*>( obj->data )->set_offsetRight( sgs_GetVarP<float>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "offsetTop" ){ static_cast<UIControl*>( obj->data )->set_offsetTop( sgs_GetVarP<float>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "offsetBottom" ){ static_cast<UIControl*>( obj->data )->set_offsetBottom( sgs_GetVarP<float>()( C, val ) ); return SGS_SUCCESS; }
		SGS_CASE( "_cachedFont" ){ static_cast<UIControl*>( obj->data )->_cachedFont = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "_cachedImage" ){ static_cast<UIControl*>( obj->data )->_cachedImage = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "_cachedIcon" ){ static_cast<UIControl*>( obj->data )->_cachedIcon = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "callback" ){ static_cast<UIControl*>( obj->data )->callback = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "data" ){ static_cast<UIControl*>( obj->data )->data = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "_interface" ){ static_cast<UIControl*>( obj->data )->_interface = sgs_GetVarP<sgsVariable>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "rx0" ){ static_cast<UIControl*>( obj->data )->rx0 = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "rx1" ){ static_cast<UIControl*>( obj->data )->rx1 = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "ry0" ){ static_cast<UIControl*>( obj->data )->ry0 = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "ry1" ){ static_cast<UIControl*>( obj->data )->ry1 = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "cx0" ){ static_cast<UIControl*>( obj->data )->cx0 = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "cx1" ){ static_cast<UIControl*>( obj->data )->cx1 = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "cy0" ){ static_cast<UIControl*>( obj->data )->cy0 = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "cy1" ){ static_cast<UIControl*>( obj->data )->cy1 = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "px0" ){ static_cast<UIControl*>( obj->data )->px0 = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "px1" ){ static_cast<UIControl*>( obj->data )->px1 = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "py0" ){ static_cast<UIControl*>( obj->data )->py0 = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "py1" ){ static_cast<UIControl*>( obj->data )->py1 = sgs_GetVarP<float>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "_updatingLayout" ){ static_cast<UIControl*>( obj->data )->_updatingLayout = sgs_GetVarP<bool>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "_roundedCoords" ){ static_cast<UIControl*>( obj->data )->_roundedCoords = sgs_GetVarP<bool>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "_childAffectsLayout" ){ static_cast<UIControl*>( obj->data )->_childAffectsLayout = sgs_GetVarP<bool>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "_clientRectFromPadded" ){ static_cast<UIControl*>( obj->data )->_clientRectFromPadded = sgs_GetVarP<bool>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "_neverHit" ){ static_cast<UIControl*>( obj->data )->_neverHit = sgs_GetVarP<bool>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "_layoutRectOverride" ){ static_cast<UIControl*>( obj->data )->_layoutRectOverride = sgs_GetVarP<bool>()( C, val ); return SGS_SUCCESS; }
		SGS_CASE( "_disableClickBubbling" ){ static_cast<UIControl*>( obj->data )->_disableClickBubbling = sgs_GetVarP<bool>()( C, val ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIControl::_sgs_dump( SGS_CTX, sgs_VarObj* obj, int depth )
{
	char bfr[ 41 ];
	sprintf( bfr, "UIControl (%p) %s", obj->data, depth > 0 ? "\n{" : " ..." );
	sgs_PushString( C, bfr );
	if( depth > 0 )
	{
		{ sgs_PushString( C, "\nid = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->id, depth ).push( C ); }
		{ sgs_PushString( C, "\nname = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->name, depth ).push( C ); }
		{ sgs_PushString( C, "\ncaption = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->caption, depth ).push( C ); }
		{ sgs_PushString( C, "\ntype = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->type, depth ).push( C ); }
		{ sgs_PushString( C, "\nfilteredStyle = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->filteredStyle, depth ).push( C ); }
		{ sgs_PushString( C, "\nstyle = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->style, depth ).push( C ); }
		{ sgs_PushString( C, "\nx = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_x(), depth ).push( C ); }
		{ sgs_PushString( C, "\ny = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_y(), depth ).push( C ); }
		{ sgs_PushString( C, "\nwidth = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_width(), depth ).push( C ); }
		{ sgs_PushString( C, "\nheight = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_height(), depth ).push( C ); }
		{ sgs_PushString( C, "\nq0x = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_q0x(), depth ).push( C ); }
		{ sgs_PushString( C, "\nq0y = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_q0y(), depth ).push( C ); }
		{ sgs_PushString( C, "\nq1x = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_q1x(), depth ).push( C ); }
		{ sgs_PushString( C, "\nq1y = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_q1y(), depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClientTop = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_nonClientTop(), depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClientLeft = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_nonClientLeft(), depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClientRight = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_nonClientRight(), depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClientBottom = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_nonClientBottom(), depth ).push( C ); }
		{ sgs_PushString( C, "\nvisible = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_visible(), depth ).push( C ); }
		{ sgs_PushString( C, "\nindex = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_index(), depth ).push( C ); }
		{ sgs_PushString( C, "\ntopmost = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_topmost(), depth ).push( C ); }
		{ sgs_PushString( C, "\nminWidth = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_minWidth(), depth ).push( C ); }
		{ sgs_PushString( C, "\nmaxWidth = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_maxWidth(), depth ).push( C ); }
		{ sgs_PushString( C, "\nminHeight = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_minHeight(), depth ).push( C ); }
		{ sgs_PushString( C, "\nmaxHeight = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_maxHeight(), depth ).push( C ); }
		{ sgs_PushString( C, "\nmarginLeft = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_marginLeft(), depth ).push( C ); }
		{ sgs_PushString( C, "\nmarginRight = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_marginRight(), depth ).push( C ); }
		{ sgs_PushString( C, "\nmarginTop = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_marginTop(), depth ).push( C ); }
		{ sgs_PushString( C, "\nmarginBottom = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_marginBottom(), depth ).push( C ); }
		{ sgs_PushString( C, "\npaddingLeft = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_paddingLeft(), depth ).push( C ); }
		{ sgs_PushString( C, "\npaddingRight = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_paddingRight(), depth ).push( C ); }
		{ sgs_PushString( C, "\npaddingTop = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_paddingTop(), depth ).push( C ); }
		{ sgs_PushString( C, "\npaddingBottom = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_paddingBottom(), depth ).push( C ); }
		{ sgs_PushString( C, "\nposMode = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_posMode(), depth ).push( C ); }
		{ sgs_PushString( C, "\nstackMode = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_stackMode(), depth ).push( C ); }
		{ sgs_PushString( C, "\noverflow = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_overflow(), depth ).push( C ); }
		{ sgs_PushString( C, "\nbackgroundColor = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_backgroundColor(), depth ).push( C ); }
		{ sgs_PushString( C, "\ntextColor = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_textColor(), depth ).push( C ); }
		{ sgs_PushString( C, "\nhalign = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_halign(), depth ).push( C ); }
		{ sgs_PushString( C, "\nvalign = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_valign(), depth ).push( C ); }
		{ sgs_PushString( C, "\ncursor = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_cursor(), depth ).push( C ); }
		{ sgs_PushString( C, "\nfont = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_font(), depth ).push( C ); }
		{ sgs_PushString( C, "\nimage = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_image(), depth ).push( C ); }
		{ sgs_PushString( C, "\nicon = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_icon(), depth ).push( C ); }
		{ sgs_PushString( C, "\nfontSize = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_fontSize(), depth ).push( C ); }
		{ sgs_PushString( C, "\nrenderfunc = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_renderfunc(), depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClientH = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_nonClientH(), depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClientV = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_nonClientV(), depth ).push( C ); }
		{ sgs_PushString( C, "\nnonClient = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_nonClient(), depth ).push( C ); }
		{ sgs_PushString( C, "\nmarginH = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_marginH(), depth ).push( C ); }
		{ sgs_PushString( C, "\nmarginV = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_marginV(), depth ).push( C ); }
		{ sgs_PushString( C, "\nmargin = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_margin(), depth ).push( C ); }
		{ sgs_PushString( C, "\npaddingH = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_paddingH(), depth ).push( C ); }
		{ sgs_PushString( C, "\npaddingV = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_paddingV(), depth ).push( C ); }
		{ sgs_PushString( C, "\npadding = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_padding(), depth ).push( C ); }
		{ sgs_PushString( C, "\nanchorMode = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_anchorMode(), depth ).push( C ); }
		{ sgs_PushString( C, "\nalign = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_align(), depth ).push( C ); }
		{ sgs_PushString( C, "\nscroll_x = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->scroll_x, depth ).push( C ); }
		{ sgs_PushString( C, "\nscroll_y = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->scroll_y, depth ).push( C ); }
		{ sgs_PushString( C, "\nnonclient = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->nonclient, depth ).push( C ); }
		{ sgs_PushString( C, "\noffsetLeft = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_offsetLeft(), depth ).push( C ); }
		{ sgs_PushString( C, "\noffsetRight = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_offsetRight(), depth ).push( C ); }
		{ sgs_PushString( C, "\noffsetTop = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_offsetTop(), depth ).push( C ); }
		{ sgs_PushString( C, "\noffsetBottom = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_offsetBottom(), depth ).push( C ); }
		{ sgs_PushString( C, "\n_cachedFont = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->_cachedFont, depth ).push( C ); }
		{ sgs_PushString( C, "\n_cachedImage = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->_cachedImage, depth ).push( C ); }
		{ sgs_PushString( C, "\n_cachedIcon = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->_cachedIcon, depth ).push( C ); }
		{ sgs_PushString( C, "\ncallback = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->callback, depth ).push( C ); }
		{ sgs_PushString( C, "\ndata = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->data, depth ).push( C ); }
		{ sgs_PushString( C, "\n_interface = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->_interface, depth ).push( C ); }
		{ sgs_PushString( C, "\nautoWidth = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->autoWidth, depth ).push( C ); }
		{ sgs_PushString( C, "\nautoHeight = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->autoHeight, depth ).push( C ); }
		{ sgs_PushString( C, "\nrx0 = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->rx0, depth ).push( C ); }
		{ sgs_PushString( C, "\nrx1 = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->rx1, depth ).push( C ); }
		{ sgs_PushString( C, "\nry0 = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->ry0, depth ).push( C ); }
		{ sgs_PushString( C, "\nry1 = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->ry1, depth ).push( C ); }
		{ sgs_PushString( C, "\nrealWidth = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_realWidth(), depth ).push( C ); }
		{ sgs_PushString( C, "\nrealHeight = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_realHeight(), depth ).push( C ); }
		{ sgs_PushString( C, "\ncx0 = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->cx0, depth ).push( C ); }
		{ sgs_PushString( C, "\ncx1 = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->cx1, depth ).push( C ); }
		{ sgs_PushString( C, "\ncy0 = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->cy0, depth ).push( C ); }
		{ sgs_PushString( C, "\ncy1 = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->cy1, depth ).push( C ); }
		{ sgs_PushString( C, "\nclientWidth = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_clientWidth(), depth ).push( C ); }
		{ sgs_PushString( C, "\nclientHeight = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_clientHeight(), depth ).push( C ); }
		{ sgs_PushString( C, "\npx0 = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->px0, depth ).push( C ); }
		{ sgs_PushString( C, "\npx1 = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->px1, depth ).push( C ); }
		{ sgs_PushString( C, "\npy0 = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->py0, depth ).push( C ); }
		{ sgs_PushString( C, "\npy1 = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->py1, depth ).push( C ); }
		{ sgs_PushString( C, "\npaddedWidth = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_paddedWidth(), depth ).push( C ); }
		{ sgs_PushString( C, "\npaddedHeight = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->get_paddedHeight(), depth ).push( C ); }
		{ sgs_PushString( C, "\n_updatingLayout = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->_updatingLayout, depth ).push( C ); }
		{ sgs_PushString( C, "\n_roundedCoords = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->_roundedCoords, depth ).push( C ); }
		{ sgs_PushString( C, "\n_childAffectsLayout = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->_childAffectsLayout, depth ).push( C ); }
		{ sgs_PushString( C, "\n_clientRectFromPadded = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->_clientRectFromPadded, depth ).push( C ); }
		{ sgs_PushString( C, "\n_neverHit = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->_neverHit, depth ).push( C ); }
		{ sgs_PushString( C, "\n_layoutRectOverride = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->_layoutRectOverride, depth ).push( C ); }
		{ sgs_PushString( C, "\n_disableClickBubbling = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->_disableClickBubbling, depth ).push( C ); }
		{ sgs_PushString( C, "\nmouseOn = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->mouseOn, depth ).push( C ); }
		{ sgs_PushString( C, "\nkeyboardFocus = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->keyboardFocus, depth ).push( C ); }
		{ sgs_PushString( C, "\nclicked = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->clicked, depth ).push( C ); }
		{ sgs_PushString( C, "\nm_children = " ); sgs_DumpData( C, static_cast<UIControl*>( obj->data )->m_children, depth ).push( C ); }
		sgs_StringConcat( C, 202 );
		sgs_PadString( C );
		sgs_PushString( C, "\n}" );
		sgs_StringConcat( C, 3 );
	}
	return SGS_SUCCESS;
}

sgs_ObjInterface UIControl::_sgs_interface[1] =
{{
	"UIControl",
	UIControl::_sgs_destruct, UIControl::_sgs_gcmark, UIControl::sgs_getindex, UIControl::sgs_setindex, NULL, NULL, UIControl::_sgs_dump, NULL, NULL, NULL, 
}};


static int _sgs_method__UIQuery__find( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, find ) ) return 0;
	sgs_PushVar(C,data->find(  )); return 1;
}

static int _sgs_method__UIQuery__children( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, children ) ) return 0;
	sgs_PushVar(C,data->children(  )); return 1;
}

static int _sgs_method__UIQuery__parent( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, parent ) ) return 0;
	sgs_PushVar(C,data->parent(  )); return 1;
}

static int _sgs_method__UIQuery__closest( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, closest ) ) return 0;
	sgs_PushVar(C,data->closest(  )); return 1;
}

static int _sgs_method__UIQuery__prev( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, prev ) ) return 0;
	sgs_PushVar(C,data->prev(  )); return 1;
}

static int _sgs_method__UIQuery__next( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, next ) ) return 0;
	sgs_PushVar(C,data->next(  )); return 1;
}

static int _sgs_method__UIQuery__prevAll( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, prevAll ) ) return 0;
	sgs_PushVar(C,data->prevAll(  )); return 1;
}

static int _sgs_method__UIQuery__nextAll( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, nextAll ) ) return 0;
	sgs_PushVar(C,data->nextAll(  )); return 1;
}

static int _sgs_method__UIQuery__filter( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, filter ) ) return 0;
	sgs_PushVar(C,data->filter(  )); return 1;
}

static int _sgs_method__UIQuery__first( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, first ) ) return 0;
	sgs_PushVar(C,data->first(  )); return 1;
}

static int _sgs_method__UIQuery__last( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, last ) ) return 0;
	sgs_PushVar(C,data->last(  )); return 1;
}

static int _sgs_method__UIQuery__getAttr( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, getAttr ) ) return 0;
	sgs_PushVar(C,data->getAttr( sgs_GetVar<sgsString>()(C,0) )); return 1;
}

static int _sgs_method__UIQuery__setAttr( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, setAttr ) ) return 0;
	sgs_PushVar(C,data->setAttr( sgs_GetVar<sgsString>()(C,0), sgs_GetVar<sgsVariable>()(C,1) )); return 1;
}

static int _sgs_method__UIQuery__addClass( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, addClass ) ) return 0;
	sgs_PushVar(C,data->addClass( sgs_GetVar<sgsString>()(C,0) )); return 1;
}

static int _sgs_method__UIQuery__removeClass( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, removeClass ) ) return 0;
	sgs_PushVar(C,data->removeClass( sgs_GetVar<sgsString>()(C,0) )); return 1;
}

static int _sgs_method__UIQuery__bindEvent( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, bindEvent ) ) return 0;
	sgs_PushVar(C,data->bindEvent( sgs_GetVar<sgsString>()(C,0), sgs_GetVar<sgsVariable>()(C,1) )); return 1;
}

static int _sgs_method__UIQuery__unbindEvent( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, unbindEvent ) ) return 0;
	sgs_PushVar(C,data->unbindEvent( sgs_GetVar<sgsString>()(C,0), sgs_GetVar<sgsVariable>()(C,1) )); return 1;
}

static int _sgs_method__UIQuery__unbindEventAll( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, unbindEventAll ) ) return 0;
	sgs_PushVar(C,data->unbindEventAll( sgs_GetVar<sgsString>()(C,0) )); return 1;
}

static int _sgs_method__UIQuery__callEvent( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, callEvent ) ) return 0;
	sgs_PushVar(C,data->callEvent( sgs_GetVar<sgsString>()(C,0), sgs_GetVar<sgsVariable>()(C,1) )); return 1;
}

static int _sgs_method__UIQuery__animate( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, animate ) ) return 0;
	sgs_PushVar(C,data->animate( sgs_GetVar<sgsVariable>()(C,0), sgs_GetVar<float>()(C,1), sgs_GetVar<sgsVariable>()(C,2), sgs_GetVar<sgsVariable>()(C,3) )); return 1;
}

static int _sgs_method__UIQuery__stop( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, stop ) ) return 0;
	sgs_PushVar(C,data->stop( sgs_GetVar<bool>()(C,0) )); return 1;
}

static int _sgs_method__UIQuery__dequeue( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, dequeue ) ) return 0;
	sgs_PushVar(C,data->dequeue(  )); return 1;
}

static int _sgs_method__UIQuery__skip( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, skip ) ) return 0;
	sgs_PushVar(C,data->skip( sgs_GetVar<bool>()(C,0) )); return 1;
}

static int _sgs_method__UIQuery__setVisible( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, setVisible ) ) return 0;
	sgs_PushVar(C,data->setVisible( sgs_GetVar<bool>()(C,0) )); return 1;
}

static int _sgs_method__UIQuery__show( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, show ) ) return 0;
	sgs_PushVar(C,data->show(  )); return 1;
}

static int _sgs_method__UIQuery__hide( SGS_CTX )
{
	UIQuery* data; if( !SGS_PARSE_METHOD( C, UIQuery::_sgs_interface, data, UIQuery, hide ) ) return 0;
	sgs_PushVar(C,data->hide(  )); return 1;
}

int UIQuery::_sgs_destruct( SGS_CTX, sgs_VarObj* obj )
{
	static_cast<UIQuery*>( obj->data )->~UIQuery();
	return SGS_SUCCESS;
}

int UIQuery::_sgs_gcmark( SGS_CTX, sgs_VarObj* obj )
{
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIQuery*>( obj->data )->m_frame ) ) ) return SGS_EINPROC;
	if( SGS_FAILED( sgs_GCMarkVar( C, static_cast<UIQuery*>( obj->data )->m_items ) ) ) return SGS_EINPROC;
	return SGS_SUCCESS;
}

int UIQuery::_sgs_getindex( SGS_ARGS_GETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
		SGS_CASE( "find" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__find ); return SGS_SUCCESS; }
		SGS_CASE( "children" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__children ); return SGS_SUCCESS; }
		SGS_CASE( "parent" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__parent ); return SGS_SUCCESS; }
		SGS_CASE( "closest" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__closest ); return SGS_SUCCESS; }
		SGS_CASE( "prev" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__prev ); return SGS_SUCCESS; }
		SGS_CASE( "next" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__next ); return SGS_SUCCESS; }
		SGS_CASE( "prevAll" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__prevAll ); return SGS_SUCCESS; }
		SGS_CASE( "nextAll" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__nextAll ); return SGS_SUCCESS; }
		SGS_CASE( "filter" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__filter ); return SGS_SUCCESS; }
		SGS_CASE( "first" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__first ); return SGS_SUCCESS; }
		SGS_CASE( "last" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__last ); return SGS_SUCCESS; }
		SGS_CASE( "getAttr" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__getAttr ); return SGS_SUCCESS; }
		SGS_CASE( "setAttr" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__setAttr ); return SGS_SUCCESS; }
		SGS_CASE( "addClass" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__addClass ); return SGS_SUCCESS; }
		SGS_CASE( "removeClass" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__removeClass ); return SGS_SUCCESS; }
		SGS_CASE( "bindEvent" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__bindEvent ); return SGS_SUCCESS; }
		SGS_CASE( "unbindEvent" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__unbindEvent ); return SGS_SUCCESS; }
		SGS_CASE( "unbindEventAll" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__unbindEventAll ); return SGS_SUCCESS; }
		SGS_CASE( "callEvent" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__callEvent ); return SGS_SUCCESS; }
		SGS_CASE( "animate" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__animate ); return SGS_SUCCESS; }
		SGS_CASE( "stop" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__stop ); return SGS_SUCCESS; }
		SGS_CASE( "dequeue" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__dequeue ); return SGS_SUCCESS; }
		SGS_CASE( "skip" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__skip ); return SGS_SUCCESS; }
		SGS_CASE( "setVisible" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__setVisible ); return SGS_SUCCESS; }
		SGS_CASE( "show" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__show ); return SGS_SUCCESS; }
		SGS_CASE( "hide" ){ sgs_PushCFunction( C, _sgs_method__UIQuery__hide ); return SGS_SUCCESS; }
		SGS_CASE( "m_frame" ){ sgs_PushVar( C, static_cast<UIQuery*>( obj->data )->m_frame ); return SGS_SUCCESS; }
	SGS_END_INDEXFUNC;
}

int UIQuery::_sgs_setindex( SGS_ARGS_SETINDEXFUNC )
{
	SGS_BEGIN_INDEXFUNC
	SGS_END_INDEXFUNC;
}

int UIQuery::_sgs_dump( SGS_CTX, sgs_VarObj* obj, int depth )
{
	char bfr[ 39 ];
	sprintf( bfr, "UIQuery (%p) %s", obj->data, depth > 0 ? "\n{" : " ..." );
	sgs_PushString( C, bfr );
	if( depth > 0 )
	{
		{ sgs_PushString( C, "\nm_frame = " ); sgs_DumpData( C, static_cast<UIQuery*>( obj->data )->m_frame, depth ).push( C ); }
		sgs_StringConcat( C, 2 );
		sgs_PadString( C );
		sgs_PushString( C, "\n}" );
		sgs_StringConcat( C, 3 );
	}
	return SGS_SUCCESS;
}

sgs_ObjInterface UIQuery::_sgs_interface[1] =
{{
	"UIQuery",
	UIQuery::_sgs_destruct, UIQuery::_sgs_gcmark, UIQuery::sgs_getindex, UIQuery::_sgs_setindex, UIQuery::sgs_convert, NULL, UIQuery::_sgs_dump, NULL, NULL, NULL, 
}};