namespace text{

Void TextFormatAlign_obj::__construct()
{
	return null();
}

//TextFormatAlign_obj::~TextFormatAlign_obj() { }

Dynamic TextFormatAlign_obj::__CreateEmpty() { return  new TextFormatAlign_obj; }
hx::ObjectPtr< TextFormatAlign_obj > TextFormatAlign_obj::__new()
{  hx::ObjectPtr< TextFormatAlign_obj > _result_ = new TextFormatAlign_obj();
	_result_->__construct();
	return _result_;}

Dynamic TextFormatAlign_obj::__Create(hx::DynamicArray inArgs)
{  hx::ObjectPtr< TextFormatAlign_obj > _result_ = new TextFormatAlign_obj();
	_result_->__construct();
	return _result_;}

::String TextFormatAlign_obj::LEFT;

::String TextFormatAlign_obj::RIGHT;

::String TextFormatAlign_obj::CENTER;

::String TextFormatAlign_obj::JUSTIFY;

::String TextFormatAlign_obj::START;

::String TextFormatAlign_obj::END;


TextFormatAlign_obj::TextFormatAlign_obj()
{
}

#if HXCPP_SCRIPTABLE
static hx::StorageInfo *sMemberStorageInfo = 0;
static hx::StaticInfo sStaticStorageInfo[] = {
	{hx::fsString,(void *) &TextFormatAlign_obj::LEFT,HX_HCSTRING("LEFT","\x07","\xd0","\x70","\x32")},
	{hx::fsString,(void *) &TextFormatAlign_obj::RIGHT,HX_HCSTRING("RIGHT","\xbc","\x43","\x52","\x67")},
	{hx::fsString,(void *) &TextFormatAlign_obj::CENTER,HX_HCSTRING("CENTER","\xd5","\xd1","\x5d","\xb8")},
	{hx::fsString,(void *) &TextFormatAlign_obj::JUSTIFY,HX_HCSTRING("JUSTIFY","\x30","\xb3","\x89","\x03")},
	{hx::fsString,(void *) &TextFormatAlign_obj::START,HX_HCSTRING("START","\x42","\xac","\xf9","\x01")},
	{hx::fsString,(void *) &TextFormatAlign_obj::END,HX_HCSTRING("END","\xbb","\x9f","\x34","\x00")},
	{ hx::fsUnknown, 0, null()}
};
#endif

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(TextFormatAlign_obj::__mClass,"__mClass");
	HX_MARK_MEMBER_NAME(TextFormatAlign_obj::LEFT,"LEFT");
	HX_MARK_MEMBER_NAME(TextFormatAlign_obj::RIGHT,"RIGHT");
	HX_MARK_MEMBER_NAME(TextFormatAlign_obj::CENTER,"CENTER");
	HX_MARK_MEMBER_NAME(TextFormatAlign_obj::JUSTIFY,"JUSTIFY");
	HX_MARK_MEMBER_NAME(TextFormatAlign_obj::START,"START");
	HX_MARK_MEMBER_NAME(TextFormatAlign_obj::END,"END");
};

#ifdef HXCPP_VISIT_ALLOCS
static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(TextFormatAlign_obj::__mClass,"__mClass");
	HX_VISIT_MEMBER_NAME(TextFormatAlign_obj::LEFT,"LEFT");
	HX_VISIT_MEMBER_NAME(TextFormatAlign_obj::RIGHT,"RIGHT");
	HX_VISIT_MEMBER_NAME(TextFormatAlign_obj::CENTER,"CENTER");
	HX_VISIT_MEMBER_NAME(TextFormatAlign_obj::JUSTIFY,"JUSTIFY");
	HX_VISIT_MEMBER_NAME(TextFormatAlign_obj::START,"START");
	HX_VISIT_MEMBER_NAME(TextFormatAlign_obj::END,"END");
};

#endif

hx::Class TextFormatAlign_obj::__mClass;

static ::String sStaticFields[] = {
	HX_HCSTRING("LEFT","\x07","\xd0","\x70","\x32"),
	HX_HCSTRING("RIGHT","\xbc","\x43","\x52","\x67"),
	HX_HCSTRING("CENTER","\xd5","\xd1","\x5d","\xb8"),
	HX_HCSTRING("JUSTIFY","\x30","\xb3","\x89","\x03"),
	HX_HCSTRING("START","\x42","\xac","\xf9","\x01"),
	HX_HCSTRING("END","\xbb","\x9f","\x34","\x00"),
	::String(null()) };

void TextFormatAlign_obj::__register()
{
	hx::Static(__mClass) = new hx::Class_obj();
	__mClass->mName = HX_HCSTRING("openfl._legacy.text.TextFormatAlign","\x64","\x64","\x77","\x30");
	__mClass->mSuper = &super::__SGetClass();
	__mClass->mConstructEmpty = &__CreateEmpty;
	__mClass->mConstructArgs = &__Create;
	__mClass->mGetStaticField = &hx::Class_obj::GetNoStaticField;
	__mClass->mSetStaticField = &hx::Class_obj::SetNoStaticField;
	__mClass->mMarkFunc = sMarkStatics;
	__mClass->mStatics = hx::Class_obj::dupFunctions(sStaticFields);
	__mClass->mMembers = hx::Class_obj::dupFunctions(0 /* sMemberFields */);
	__mClass->mCanCast = hx::TCanCast< TextFormatAlign_obj >;
#ifdef HXCPP_VISIT_ALLOCS
	__mClass->mVisitFunc = sVisitStatics;
#endif
#ifdef HXCPP_SCRIPTABLE
	__mClass->mMemberStorageInfo = sMemberStorageInfo;
#endif
#ifdef HXCPP_SCRIPTABLE
	__mClass->mStaticStorageInfo = sStaticStorageInfo;
#endif
	hx::RegisterClass(__mClass->mName, __mClass);
}

void TextFormatAlign_obj::__boot()
{
	LEFT= HX_HCSTRING("left","\x07","\x08","\xb0","\x47");
	RIGHT= HX_HCSTRING("right","\xdc","\x0b","\x64","\xe9");
	CENTER= HX_HCSTRING("center","\xd5","\x25","\xdb","\x05");
	JUSTIFY= HX_HCSTRING("justify","\x50","\xdf","\xb5","\x83");
	START= HX_HCSTRING("left","\x07","\x08","\xb0","\x47");
	END= HX_HCSTRING("right","\xdc","\x0b","\x64","\xe9");
}

} // end namespace openfl
Beispiel #2
0
#ifndef INCLUDED_openfl_events_IEventDispatcher
#include <openfl/events/IEventDispatcher.h>
#endif

Void Source_obj::__construct(::Sources kind)
{
HX_STACK_FRAME("Source","new",0x52f75f6d,"Source.new","Source.hx",12,0x0ab42ca3)
HX_STACK_THIS(this)
HX_STACK_ARG(kind,"kind")
{
	HX_STACK_LINE(13)
	::Sources tmp = kind;		HX_STACK_VAR(tmp,"tmp");
	HX_STACK_LINE(13)
	::String tmp1 = ::Std_obj::string(tmp);		HX_STACK_VAR(tmp1,"tmp1");
	HX_STACK_LINE(13)
	::String tmp2 = (HX_HCSTRING("sources/","\xf7","\x41","\xa4","\x66") + tmp1);		HX_STACK_VAR(tmp2,"tmp2");
	HX_STACK_LINE(13)
	::String png = tmp2;		HX_STACK_VAR(png,"png");
	HX_STACK_LINE(14)
	::String tmp3 = png;		HX_STACK_VAR(tmp3,"tmp3");
	HX_STACK_LINE(14)
	super::__construct(tmp3,(int)180,(int)180);
	HX_STACK_LINE(15)
	this->kind = kind;
}
;
	return null();
}

//Source_obj::~Source_obj() { }
void GraphicVirtualInput_obj::__boot()
{
	resourceName= HX_HCSTRING("__ASSET__:bitmap_flixel_system_GraphicVirtualInput","\x34","\xa9","\x10","\xf7");
}
Beispiel #4
0
static void ConsoleUtil_obj_sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(ConsoleUtil_obj::__mClass,"__mClass");
};

#ifdef HXCPP_VISIT_ALLOCS
static void ConsoleUtil_obj_sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(ConsoleUtil_obj::__mClass,"__mClass");
};

#endif

hx::Class ConsoleUtil_obj::__mClass;

static ::String ConsoleUtil_obj_sStaticFields[] = {
	HX_HCSTRING("getFields","\xaf","\x17","\xe5","\xfc"),
	HX_HCSTRING("sortFields","\x77","\x04","\x74","\xdd"),
	HX_HCSTRING("log","\x84","\x54","\x52","\x00"),
	::String(null())
};

void ConsoleUtil_obj::__register()
{
	hx::Static(__mClass) = new hx::Class_obj();
	__mClass->mName = HX_HCSTRING("flixel.system.debug.console.ConsoleUtil","\xba","\x4f","\xd6","\xa9");
	__mClass->mSuper = &super::__SGetClass();
	__mClass->mConstructEmpty = &__CreateEmpty;
	__mClass->mConstructArgs = &__Create;
	__mClass->mGetStaticField = &ConsoleUtil_obj::__GetStatic;
	__mClass->mSetStaticField = &hx::Class_obj::SetNoStaticField;
	__mClass->mMarkFunc = ConsoleUtil_obj_sMarkStatics;
namespace _hx_system{

void ScreenMode_obj::__construct(){
            	HX_STACK_FRAME("openfl._legacy.system.ScreenMode","new",0x975af1bc,"openfl._legacy.system.ScreenMode.new","openfl/_legacy/system/ScreenMode.hx",9,0xb2cfa295)
            	HX_STACK_THIS(this)
HXLINE(  10)		this->width = (int)-1;
HXLINE(  11)		this->height = (int)-1;
HXLINE(  12)		this->format = null();
HXLINE(  13)		this->refreshRate = (int)-1;
            	}

Dynamic ScreenMode_obj::__CreateEmpty() { return new ScreenMode_obj; }

hx::ObjectPtr< ScreenMode_obj > ScreenMode_obj::__new()
{
	hx::ObjectPtr< ScreenMode_obj > _hx_result = new ScreenMode_obj();
	_hx_result->__construct();
	return _hx_result;
}

Dynamic ScreenMode_obj::__Create(hx::DynamicArray inArgs)
{
	hx::ObjectPtr< ScreenMode_obj > _hx_result = new ScreenMode_obj();
	_hx_result->__construct();
	return _hx_result;
}


ScreenMode_obj::ScreenMode_obj()
{
}

void ScreenMode_obj::__Mark(HX_MARK_PARAMS)
{
	HX_MARK_BEGIN_CLASS(ScreenMode);
	HX_MARK_MEMBER_NAME(format,"format");
	HX_MARK_MEMBER_NAME(width,"width");
	HX_MARK_MEMBER_NAME(height,"height");
	HX_MARK_MEMBER_NAME(refreshRate,"refreshRate");
	HX_MARK_END_CLASS();
}

void ScreenMode_obj::__Visit(HX_VISIT_PARAMS)
{
	HX_VISIT_MEMBER_NAME(format,"format");
	HX_VISIT_MEMBER_NAME(width,"width");
	HX_VISIT_MEMBER_NAME(height,"height");
	HX_VISIT_MEMBER_NAME(refreshRate,"refreshRate");
}

hx::Val ScreenMode_obj::__Field(const ::String &inName,hx::PropertyAccess inCallProp)
{
	switch(inName.length) {
	case 5:
		if (HX_FIELD_EQ(inName,"width") ) { return hx::Val( width); }
		break;
	case 6:
		if (HX_FIELD_EQ(inName,"format") ) { return hx::Val( format); }
		if (HX_FIELD_EQ(inName,"height") ) { return hx::Val( height); }
		break;
	case 11:
		if (HX_FIELD_EQ(inName,"refreshRate") ) { return hx::Val( refreshRate); }
	}
	return super::__Field(inName,inCallProp);
}

hx::Val ScreenMode_obj::__SetField(const ::String &inName,const hx::Val &inValue,hx::PropertyAccess inCallProp)
{
	switch(inName.length) {
	case 5:
		if (HX_FIELD_EQ(inName,"width") ) { width=inValue.Cast< Int >(); return inValue; }
		break;
	case 6:
		if (HX_FIELD_EQ(inName,"format") ) { format=inValue.Cast< ::hx::EnumBase >(); return inValue; }
		if (HX_FIELD_EQ(inName,"height") ) { height=inValue.Cast< Int >(); return inValue; }
		break;
	case 11:
		if (HX_FIELD_EQ(inName,"refreshRate") ) { refreshRate=inValue.Cast< Int >(); return inValue; }
	}
	return super::__SetField(inName,inValue,inCallProp);
}

void ScreenMode_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_HCSTRING("format","\x37","\x8f","\x8e","\xfd"));
	outFields->push(HX_HCSTRING("width","\x06","\xb6","\x62","\xca"));
	outFields->push(HX_HCSTRING("height","\xe7","\x07","\x4c","\x02"));
	outFields->push(HX_HCSTRING("refreshRate","\x5b","\xe2","\x3f","\x40"));
	super::__GetFields(outFields);
};

#if HXCPP_SCRIPTABLE
static hx::StorageInfo ScreenMode_obj_sMemberStorageInfo[] = {
	{hx::fsObject /*::openfl::_legacy::_hx_system::PixelFormat*/ ,(int)offsetof(ScreenMode_obj,format),HX_HCSTRING("format","\x37","\x8f","\x8e","\xfd")},
	{hx::fsInt,(int)offsetof(ScreenMode_obj,width),HX_HCSTRING("width","\x06","\xb6","\x62","\xca")},
	{hx::fsInt,(int)offsetof(ScreenMode_obj,height),HX_HCSTRING("height","\xe7","\x07","\x4c","\x02")},
	{hx::fsInt,(int)offsetof(ScreenMode_obj,refreshRate),HX_HCSTRING("refreshRate","\x5b","\xe2","\x3f","\x40")},
	{ hx::fsUnknown, 0, null()}
};
static hx::StaticInfo *ScreenMode_obj_sStaticStorageInfo = 0;
#endif

static ::String ScreenMode_obj_sMemberFields[] = {
	HX_HCSTRING("format","\x37","\x8f","\x8e","\xfd"),
	HX_HCSTRING("width","\x06","\xb6","\x62","\xca"),
	HX_HCSTRING("height","\xe7","\x07","\x4c","\x02"),
	HX_HCSTRING("refreshRate","\x5b","\xe2","\x3f","\x40"),
	::String(null()) };

static void ScreenMode_obj_sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(ScreenMode_obj::__mClass,"__mClass");
};

#ifdef HXCPP_VISIT_ALLOCS
static void ScreenMode_obj_sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(ScreenMode_obj::__mClass,"__mClass");
};

#endif

hx::Class ScreenMode_obj::__mClass;

void ScreenMode_obj::__register()
{
	hx::Static(__mClass) = new hx::Class_obj();
	__mClass->mName = HX_HCSTRING("openfl._legacy.system.ScreenMode","\xca","\xa3","\x20","\xc9");
	__mClass->mSuper = &super::__SGetClass();
	__mClass->mConstructEmpty = &__CreateEmpty;
	__mClass->mConstructArgs = &__Create;
	__mClass->mGetStaticField = &hx::Class_obj::GetNoStaticField;
	__mClass->mSetStaticField = &hx::Class_obj::SetNoStaticField;
	__mClass->mMarkFunc = ScreenMode_obj_sMarkStatics;
	__mClass->mStatics = hx::Class_obj::dupFunctions(0 /* sStaticFields */);
	__mClass->mMembers = hx::Class_obj::dupFunctions(ScreenMode_obj_sMemberFields);
	__mClass->mCanCast = hx::TCanCast< ScreenMode_obj >;
#ifdef HXCPP_VISIT_ALLOCS
	__mClass->mVisitFunc = ScreenMode_obj_sVisitStatics;
#endif
#ifdef HXCPP_SCRIPTABLE
	__mClass->mMemberStorageInfo = ScreenMode_obj_sMemberStorageInfo;
#endif
#ifdef HXCPP_SCRIPTABLE
	__mClass->mStaticStorageInfo = ScreenMode_obj_sStaticStorageInfo;
#endif
	hx::_hx_RegisterClass(__mClass->mName, __mClass);
}

} // end namespace openfl
void ZNPNode_ZPP_SensorArbiter_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_HCSTRING("next","\xf3","\x84","\x02","\x49"));
	outFields->push(HX_HCSTRING("elt","\x2d","\x02","\x4d","\x00"));
	super::__GetFields(outFields);
};
Beispiel #7
0
namespace thx{

void ResourceTest_obj::__construct() { }

Dynamic ResourceTest_obj::__CreateEmpty() { return new ResourceTest_obj; }

hx::ObjectPtr< ResourceTest_obj > ResourceTest_obj::__new()
{
	hx::ObjectPtr< ResourceTest_obj > _hx_result = new ResourceTest_obj();
	_hx_result->__construct();
	return _hx_result;
}

Dynamic ResourceTest_obj::__Create(hx::DynamicArray inArgs)
{
	hx::ObjectPtr< ResourceTest_obj > _hx_result = new ResourceTest_obj();
	_hx_result->__construct();
	return _hx_result;
}

static ::thx::StaticResource_obj _hx_thx_ResourceTest__hx_thx_StaticResource= {
};

void *ResourceTest_obj::_hx_getInterface(int inHash) {
	switch(inHash) {
		case (int)0x6cb11300: return &_hx_thx_ResourceTest__hx_thx_StaticResource;
	}
	#ifdef HXCPP_SCRIPTABLE
	return super::_hx_getInterface(inHash);
	#else
	return 0;
	#endif
}

 ::Dynamic ResourceTest_obj::fileJson;

::String ResourceTest_obj::fileText;

Int ResourceTest_obj::a;

 ::Dynamic ResourceTest_obj::b;

Bool ResourceTest_obj::c;

::String ResourceTest_obj::d;


ResourceTest_obj::ResourceTest_obj()
{
}

bool ResourceTest_obj::__GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp)
{
	switch(inName.length) {
	case 1:
		if (HX_FIELD_EQ(inName,"a") ) { outValue = a; return true; }
		if (HX_FIELD_EQ(inName,"b") ) { outValue = b; return true; }
		if (HX_FIELD_EQ(inName,"c") ) { outValue = c; return true; }
		if (HX_FIELD_EQ(inName,"d") ) { outValue = d; return true; }
		break;
	case 8:
		if (HX_FIELD_EQ(inName,"fileJson") ) { outValue = fileJson; return true; }
		if (HX_FIELD_EQ(inName,"fileText") ) { outValue = fileText; return true; }
	}
	return false;
}

bool ResourceTest_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,hx::PropertyAccess inCallProp)
{
	switch(inName.length) {
	case 1:
		if (HX_FIELD_EQ(inName,"a") ) { a=ioValue.Cast< Int >(); return true; }
		if (HX_FIELD_EQ(inName,"b") ) { b=ioValue.Cast<  ::Dynamic >(); return true; }
		if (HX_FIELD_EQ(inName,"c") ) { c=ioValue.Cast< Bool >(); return true; }
		if (HX_FIELD_EQ(inName,"d") ) { d=ioValue.Cast< ::String >(); return true; }
		break;
	case 8:
		if (HX_FIELD_EQ(inName,"fileJson") ) { fileJson=ioValue.Cast<  ::Dynamic >(); return true; }
		if (HX_FIELD_EQ(inName,"fileText") ) { fileText=ioValue.Cast< ::String >(); return true; }
	}
	return false;
}

#if HXCPP_SCRIPTABLE
static hx::StorageInfo *ResourceTest_obj_sMemberStorageInfo = 0;
static hx::StaticInfo ResourceTest_obj_sStaticStorageInfo[] = {
	{hx::fsObject /*Dynamic*/ ,(void *) &ResourceTest_obj::fileJson,HX_HCSTRING("fileJson","\xc4","\x2a","\xac","\x5f")},
	{hx::fsString,(void *) &ResourceTest_obj::fileText,HX_HCSTRING("fileText","\x49","\xb5","\x3d","\x66")},
	{hx::fsInt,(void *) &ResourceTest_obj::a,HX_HCSTRING("a","\x61","\x00","\x00","\x00")},
	{hx::fsObject /*Dynamic*/ ,(void *) &ResourceTest_obj::b,HX_HCSTRING("b","\x62","\x00","\x00","\x00")},
	{hx::fsBool,(void *) &ResourceTest_obj::c,HX_HCSTRING("c","\x63","\x00","\x00","\x00")},
	{hx::fsString,(void *) &ResourceTest_obj::d,HX_HCSTRING("d","\x64","\x00","\x00","\x00")},
	{ hx::fsUnknown, 0, null()}
};
#endif

static void ResourceTest_obj_sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(ResourceTest_obj::__mClass,"__mClass");
	HX_MARK_MEMBER_NAME(ResourceTest_obj::fileJson,"fileJson");
	HX_MARK_MEMBER_NAME(ResourceTest_obj::fileText,"fileText");
	HX_MARK_MEMBER_NAME(ResourceTest_obj::a,"a");
	HX_MARK_MEMBER_NAME(ResourceTest_obj::b,"b");
	HX_MARK_MEMBER_NAME(ResourceTest_obj::c,"c");
	HX_MARK_MEMBER_NAME(ResourceTest_obj::d,"d");
};

#ifdef HXCPP_VISIT_ALLOCS
static void ResourceTest_obj_sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(ResourceTest_obj::__mClass,"__mClass");
	HX_VISIT_MEMBER_NAME(ResourceTest_obj::fileJson,"fileJson");
	HX_VISIT_MEMBER_NAME(ResourceTest_obj::fileText,"fileText");
	HX_VISIT_MEMBER_NAME(ResourceTest_obj::a,"a");
	HX_VISIT_MEMBER_NAME(ResourceTest_obj::b,"b");
	HX_VISIT_MEMBER_NAME(ResourceTest_obj::c,"c");
	HX_VISIT_MEMBER_NAME(ResourceTest_obj::d,"d");
};

#endif

hx::Class ResourceTest_obj::__mClass;

static ::String ResourceTest_obj_sStaticFields[] = {
	HX_HCSTRING("fileJson","\xc4","\x2a","\xac","\x5f"),
	HX_HCSTRING("fileText","\x49","\xb5","\x3d","\x66"),
	HX_HCSTRING("a","\x61","\x00","\x00","\x00"),
	HX_HCSTRING("b","\x62","\x00","\x00","\x00"),
	HX_HCSTRING("c","\x63","\x00","\x00","\x00"),
	HX_HCSTRING("d","\x64","\x00","\x00","\x00"),
	::String(null())
};

void ResourceTest_obj::__register()
{
	hx::Static(__mClass) = new hx::Class_obj();
	__mClass->mName = HX_HCSTRING("thx.ResourceTest","\x8a","\x46","\x50","\xee");
	__mClass->mSuper = &super::__SGetClass();
	__mClass->mConstructEmpty = &__CreateEmpty;
	__mClass->mConstructArgs = &__Create;
	__mClass->mGetStaticField = &ResourceTest_obj::__GetStatic;
	__mClass->mSetStaticField = &ResourceTest_obj::__SetStatic;
	__mClass->mMarkFunc = ResourceTest_obj_sMarkStatics;
	__mClass->mStatics = hx::Class_obj::dupFunctions(ResourceTest_obj_sStaticFields);
	__mClass->mMembers = hx::Class_obj::dupFunctions(0 /* sMemberFields */);
	__mClass->mCanCast = hx::TCanCast< ResourceTest_obj >;
#ifdef HXCPP_VISIT_ALLOCS
	__mClass->mVisitFunc = ResourceTest_obj_sVisitStatics;
#endif
#ifdef HXCPP_SCRIPTABLE
	__mClass->mMemberStorageInfo = ResourceTest_obj_sMemberStorageInfo;
#endif
#ifdef HXCPP_SCRIPTABLE
	__mClass->mStaticStorageInfo = ResourceTest_obj_sStaticStorageInfo;
#endif
	hx::_hx_RegisterClass(__mClass->mName, __mClass);
}

void ResourceTest_obj::__boot()
{
{
            	HX_STACK_FRAME("thx.ResourceTest","boot",0x15bbf896,"thx.ResourceTest.boot","thx/macro/BuildResource.hx",26,0xef86e250)
HXLINE(  26)		fileJson =  ::Dynamic(hx::Anon_obj::Create(1)
            			->setFixed(0,HX_("some",f4,22,58,4c),HX_("value",71,7f,b8,31)));
            	}
{
            	HX_STACK_FRAME("thx.ResourceTest","boot",0x15bbf896,"thx.ResourceTest.boot","thx/macro/BuildResource.hx",26,0xef86e250)
HXLINE(  26)		fileText = HX_("some text\n",91,a8,97,73);
            	}
{
            	HX_STACK_FRAME("thx.ResourceTest","boot",0x15bbf896,"thx.ResourceTest.boot","thx/macro/BuildResource.hx",26,0xef86e250)
HXLINE(  26)		a = (int)1;
            	}
{
            	HX_STACK_FRAME("thx.ResourceTest","boot",0x15bbf896,"thx.ResourceTest.boot","thx/macro/BuildResource.hx",26,0xef86e250)
HXLINE(  26)		b =  ::Dynamic(hx::Anon_obj::Create(1)
            			->setFixed(0,HX_("s",73,00,00,00),HX_("thx",84,60,58,00)));
            	}
{
            	HX_STACK_FRAME("thx.ResourceTest","boot",0x15bbf896,"thx.ResourceTest.boot","thx/macro/BuildResource.hx",26,0xef86e250)
HXLINE(  26)		c = true;
            	}
{
            	HX_STACK_FRAME("thx.ResourceTest","boot",0x15bbf896,"thx.ResourceTest.boot","thx/macro/BuildResource.hx",26,0xef86e250)
HXLINE(  26)		d = HX_("haxe",26,34,08,45);
            	}
}

} // end namespace thx
Beispiel #8
0
}

void BaseScaleMode_obj::__GetFields(Array< ::String> &outFields)
{
    outFields->push(HX_HCSTRING("deviceSize","\x77","\xac","\xdd","\xb5"));
    outFields->push(HX_HCSTRING("gameSize","\xd3","\xa1","\x79","\xb8"));
    outFields->push(HX_HCSTRING("scale","\x8a","\xce","\xce","\x78"));
    outFields->push(HX_HCSTRING("offset","\x93","\x97","\x3f","\x60"));
    outFields->push(HX_HCSTRING("horizontalAlign","\x41","\x8f","\x67","\xf4"));
    outFields->push(HX_HCSTRING("verticalAlign","\x6f","\x1e","\x7c","\xe4"));
    super::__GetFields(outFields);
};

#if HXCPP_SCRIPTABLE
static hx::StorageInfo BaseScaleMode_obj_sMemberStorageInfo[] = {
    {hx::fsObject /*::flixel::math::FlxPoint*/ ,(int)offsetof(BaseScaleMode_obj,deviceSize),HX_HCSTRING("deviceSize","\x77","\xac","\xdd","\xb5")},
    {hx::fsObject /*::flixel::math::FlxPoint*/ ,(int)offsetof(BaseScaleMode_obj,gameSize),HX_HCSTRING("gameSize","\xd3","\xa1","\x79","\xb8")},
    {hx::fsObject /*::flixel::math::FlxPoint*/ ,(int)offsetof(BaseScaleMode_obj,scale),HX_HCSTRING("scale","\x8a","\xce","\xce","\x78")},
    {hx::fsObject /*::flixel::math::FlxPoint*/ ,(int)offsetof(BaseScaleMode_obj,offset),HX_HCSTRING("offset","\x93","\x97","\x3f","\x60")},
    {hx::fsObject /*::flixel::util::FlxHorizontalAlign*/ ,(int)offsetof(BaseScaleMode_obj,horizontalAlign),HX_HCSTRING("horizontalAlign","\x41","\x8f","\x67","\xf4")},
    {hx::fsObject /*::flixel::util::FlxVerticalAlign*/ ,(int)offsetof(BaseScaleMode_obj,verticalAlign),HX_HCSTRING("verticalAlign","\x6f","\x1e","\x7c","\xe4")},
    { hx::fsUnknown, 0, null()}
};
static hx::StaticInfo *BaseScaleMode_obj_sStaticStorageInfo = 0;
#endif

static ::String BaseScaleMode_obj_sMemberFields[] = {
    HX_HCSTRING("deviceSize","\x77","\xac","\xdd","\xb5"),
    HX_HCSTRING("gameSize","\xd3","\xa1","\x79","\xb8"),
    HX_HCSTRING("scale","\x8a","\xce","\xce","\x78"),
    HX_HCSTRING("offset","\x93","\x97","\x3f","\x60"),
Beispiel #9
0
void DrawCommandType_obj::__boot()
{
hx::Static(BEGIN_BITMAP_FILL) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("BEGIN_BITMAP_FILL","\x9d","\x8d","\xc1","\xd5"),0);
hx::Static(BEGIN_FILL) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("BEGIN_FILL","\xb9","\x8f","\x44","\x38"),1);
hx::Static(BEGIN_GRADIENT_FILL) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("BEGIN_GRADIENT_FILL","\x7c","\x12","\x1d","\xec"),2);
hx::Static(CUBIC_CURVE_TO) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("CUBIC_CURVE_TO","\x60","\x8b","\x92","\xac"),3);
hx::Static(CURVE_TO) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("CURVE_TO","\x6b","\xde","\x71","\x42"),4);
hx::Static(DRAW_CIRCLE) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("DRAW_CIRCLE","\x2b","\x84","\x66","\x49"),5);
hx::Static(DRAW_ELLIPSE) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("DRAW_ELLIPSE","\x43","\x06","\x1d","\x06"),6);
hx::Static(DRAW_PATH) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("DRAW_PATH","\x00","\xc7","\x6b","\x9a"),7);
hx::Static(DRAW_RECT) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("DRAW_RECT","\x7f","\x2e","\xc1","\x9b"),8);
hx::Static(DRAW_ROUND_RECT) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("DRAW_ROUND_RECT","\xb0","\xa9","\x34","\x42"),9);
hx::Static(DRAW_TILES) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("DRAW_TILES","\xaa","\x4b","\xc0","\xd6"),10);
hx::Static(DRAW_TRIANGLES) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("DRAW_TRIANGLES","\x50","\xbd","\x1f","\x61"),11);
hx::Static(END_FILL) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("END_FILL","\xc7","\x2c","\xf5","\x27"),12);
hx::Static(LINE_BITMAP_STYLE) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("LINE_BITMAP_STYLE","\xec","\xc7","\x38","\x2d"),13);
hx::Static(LINE_GRADIENT_STYLE) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("LINE_GRADIENT_STYLE","\x6d","\x7d","\x1a","\xa1"),14);
hx::Static(LINE_STYLE) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("LINE_STYLE","\x46","\x73","\x8d","\xdd"),15);
hx::Static(LINE_TO) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("LINE_TO","\x26","\xf0","\x91","\x9f"),16);
hx::Static(MOVE_TO) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("MOVE_TO","\x29","\x35","\x80","\xca"),17);
hx::Static(OVERRIDE_MATRIX) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("OVERRIDE_MATRIX","\x14","\x63","\x08","\xa8"),18);
hx::Static(UNKNOWN) = hx::CreateEnum< DrawCommandType_obj >(HX_HCSTRING("UNKNOWN","\x6a","\xf7","\x4e","\x61"),19);
}
void GraphicWatch_obj::__boot()
{
	resourceName= HX_HCSTRING("__ASSET__:bitmap_flixel_system_debug_GraphicWatch","\x66","\x8f","\x5d","\x86");
}
void __ASSET__assets_fonts_nokiafc22_ttf_obj::__boot()
{
	resourceName= HX_HCSTRING("NME_font___ASSET__assets_fonts_nokiafc22_ttf","\xa8","\xaf","\x6b","\x88");
}
void FlxSignalHandler_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_HCSTRING("listener","\x74","\x00","\x32","\x38"));
	outFields->push(HX_HCSTRING("dispatchOnce","\x5b","\x5d","\x76","\x64"));
	super::__GetFields(outFields);
};
bool FlxSignalHandler_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,hx::PropertyAccess inCallProp)
{
	return false;
}

void FlxSignalHandler_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_HCSTRING("listener","\x74","\x00","\x32","\x38"));
	outFields->push(HX_HCSTRING("dispatchOnce","\x5b","\x5d","\x76","\x64"));
	super::__GetFields(outFields);
};

#if HXCPP_SCRIPTABLE
static hx::StorageInfo sMemberStorageInfo[] = {
	{hx::fsObject /*Dynamic*/ ,(int)offsetof(FlxSignalHandler_obj,listener),HX_HCSTRING("listener","\x74","\x00","\x32","\x38")},
	{hx::fsBool,(int)offsetof(FlxSignalHandler_obj,dispatchOnce),HX_HCSTRING("dispatchOnce","\x5b","\x5d","\x76","\x64")},
	{ hx::fsUnknown, 0, null()}
};
static hx::StaticInfo *sStaticStorageInfo = 0;
#endif

static ::String sMemberFields[] = {
	HX_HCSTRING("listener","\x74","\x00","\x32","\x38"),
	HX_HCSTRING("dispatchOnce","\x5b","\x5d","\x76","\x64"),
	HX_HCSTRING("destroy","\xfa","\x2c","\x86","\x24"),
	::String(null()) };

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(FlxSignalHandler_obj::__mClass,"__mClass");
};
Beispiel #14
0
::String Xml_obj::get( ::String att){
	HX_STACK_FRAME("Xml","get",0x2e441e5f,"Xml.get","C:\\HaxeToolkit\\haxe\\std/Xml.hx",166,0x6fe08e00)
	HX_STACK_THIS(this)
	HX_STACK_ARG(att,"att")
	HX_STACK_LINE(167)
	int tmp = this->nodeType;		HX_STACK_VAR(tmp,"tmp");
	HX_STACK_LINE(167)
	int tmp1 = ::Xml_obj::Element;		HX_STACK_VAR(tmp1,"tmp1");
	HX_STACK_LINE(167)
	bool tmp2 = (tmp != tmp1);		HX_STACK_VAR(tmp2,"tmp2");
	HX_STACK_LINE(167)
	if ((tmp2)){
		HX_STACK_LINE(168)
		int tmp3 = this->nodeType;		HX_STACK_VAR(tmp3,"tmp3");
		HX_STACK_LINE(168)
		::String tmp4 = (HX_HCSTRING("Bad node type, expected Element but found ","\xd8","\x90","\x8b","\xbb") + tmp3);		HX_STACK_VAR(tmp4,"tmp4");
		HX_STACK_LINE(168)
		HX_STACK_DO_THROW(tmp4);
	}
	HX_STACK_LINE(170)
	::haxe::ds::StringMap tmp3 = this->attributeMap;		HX_STACK_VAR(tmp3,"tmp3");
	HX_STACK_LINE(170)
	::String tmp4 = att;		HX_STACK_VAR(tmp4,"tmp4");
	HX_STACK_LINE(170)
	::String tmp5 = tmp3->get(tmp4);		HX_STACK_VAR(tmp5,"tmp5");
	HX_STACK_LINE(170)
	::String tmp6 = tmp5;		HX_STACK_VAR(tmp6,"tmp6");
	HX_STACK_LINE(170)
	return tmp6;
}
Beispiel #15
0
	return false;
}

bool __ASSET__flixel_fonts_nokiafc22_ttf_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,hx::PropertyAccess inCallProp)
{
	switch(inName.length) {
	case 12:
		if (HX_FIELD_EQ(inName,"resourceName") ) { resourceName=ioValue.Cast< ::String >(); return true; }
	}
	return false;
}

#if HXCPP_SCRIPTABLE
static hx::StorageInfo *__ASSET__flixel_fonts_nokiafc22_ttf_obj_sMemberStorageInfo = 0;
static hx::StaticInfo __ASSET__flixel_fonts_nokiafc22_ttf_obj_sStaticStorageInfo[] = {
	{hx::fsString,(void *) &__ASSET__flixel_fonts_nokiafc22_ttf_obj::resourceName,HX_HCSTRING("resourceName","\x39","\x7a","\x62","\x90")},
	{ hx::fsUnknown, 0, null()}
};
#endif

static void __ASSET__flixel_fonts_nokiafc22_ttf_obj_sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(__ASSET__flixel_fonts_nokiafc22_ttf_obj::__mClass,"__mClass");
	HX_MARK_MEMBER_NAME(__ASSET__flixel_fonts_nokiafc22_ttf_obj::resourceName,"resourceName");
};

#ifdef HXCPP_VISIT_ALLOCS
static void __ASSET__flixel_fonts_nokiafc22_ttf_obj_sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(__ASSET__flixel_fonts_nokiafc22_ttf_obj::__mClass,"__mClass");
	HX_VISIT_MEMBER_NAME(__ASSET__flixel_fonts_nokiafc22_ttf_obj::resourceName,"resourceName");
};
	HX_VISIT_MEMBER_NAME(InputEventType_Impl__obj::__mClass,"__mClass");
	HX_VISIT_MEMBER_NAME(InputEventType_Impl__obj::ie_unknown,"ie_unknown");
	HX_VISIT_MEMBER_NAME(InputEventType_Impl__obj::ie_key,"ie_key");
	HX_VISIT_MEMBER_NAME(InputEventType_Impl__obj::ie_text,"ie_text");
	HX_VISIT_MEMBER_NAME(InputEventType_Impl__obj::ie_mouse,"ie_mouse");
	HX_VISIT_MEMBER_NAME(InputEventType_Impl__obj::ie_touch,"ie_touch");
	HX_VISIT_MEMBER_NAME(InputEventType_Impl__obj::ie_gamepad,"ie_gamepad");
	HX_VISIT_MEMBER_NAME(InputEventType_Impl__obj::ie_joystick,"ie_joystick");
};

#endif

hx::Class InputEventType_Impl__obj::__mClass;

static ::String sStaticFields[] = {
	HX_HCSTRING("ie_unknown","\xe7","\x14","\xfd","\x32"),
	HX_HCSTRING("ie_key","\x7c","\x48","\x0e","\x62"),
	HX_HCSTRING("ie_text","\x30","\x0f","\x64","\x70"),
	HX_HCSTRING("ie_mouse","\x42","\x06","\xf5","\xe5"),
	HX_HCSTRING("ie_touch","\xdc","\x07","\xc3","\xed"),
	HX_HCSTRING("ie_gamepad","\xfe","\xd1","\x07","\xdb"),
	HX_HCSTRING("ie_joystick","\xbf","\x20","\x23","\x9c"),
	HX_HCSTRING("toString","\xac","\xd0","\x6e","\x38"),
	::String(null()) };

void InputEventType_Impl__obj::__register()
{
	hx::Static(__mClass) = new hx::Class_obj();
	__mClass->mName = HX_HCSTRING("snow.types._Types.InputEventType_Impl_","\xfe","\x73","\x4c","\x50");
	__mClass->mSuper = &super::__SGetClass();
	__mClass->mConstructEmpty = &__CreateEmpty;
	case 8:
		if (HX_FIELD_EQ(inName,"zpp_pool") ) { zpp_pool=ioValue.Cast< ::zpp_nape::util::ZNPNode_ZPP_SensorArbiter >(); return true; }
	}
	return false;
}

void ZNPNode_ZPP_SensorArbiter_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_HCSTRING("next","\xf3","\x84","\x02","\x49"));
	outFields->push(HX_HCSTRING("elt","\x2d","\x02","\x4d","\x00"));
	super::__GetFields(outFields);
};

#if HXCPP_SCRIPTABLE
static hx::StorageInfo sMemberStorageInfo[] = {
	{hx::fsObject /*::zpp_nape::util::ZNPNode_ZPP_SensorArbiter*/ ,(int)offsetof(ZNPNode_ZPP_SensorArbiter_obj,next),HX_HCSTRING("next","\xf3","\x84","\x02","\x49")},
	{hx::fsObject /*::zpp_nape::dynamics::ZPP_SensorArbiter*/ ,(int)offsetof(ZNPNode_ZPP_SensorArbiter_obj,elt),HX_HCSTRING("elt","\x2d","\x02","\x4d","\x00")},
	{ hx::fsUnknown, 0, null()}
};
static hx::StaticInfo sStaticStorageInfo[] = {
	{hx::fsObject /*::zpp_nape::util::ZNPNode_ZPP_SensorArbiter*/ ,(void *) &ZNPNode_ZPP_SensorArbiter_obj::zpp_pool,HX_HCSTRING("zpp_pool","\x81","\x5d","\xd4","\x38")},
	{ hx::fsUnknown, 0, null()}
};
#endif

static ::String sMemberFields[] = {
	HX_HCSTRING("next","\xf3","\x84","\x02","\x49"),
	HX_HCSTRING("alloc","\x75","\xa4","\x93","\x21"),
	HX_HCSTRING("free","\xac","\x9c","\xc2","\x43"),
	HX_HCSTRING("elt","\x2d","\x02","\x4d","\x00"),
	HX_HCSTRING("elem","\x8f","\xd8","\x14","\x43"),
Beispiel #18
0
namespace net{

Void URLRequestHeader_obj::__construct(::String __o_name,::String __o_value)
{
HX_STACK_FRAME("lime.net.URLRequestHeader","new",0x55a21f09,"lime.net.URLRequestHeader.new","lime/net/URLRequestHeader.hx",11,0xc3cdd945)
HX_STACK_THIS(this)
HX_STACK_ARG(__o_name,"name")
HX_STACK_ARG(__o_value,"value")
::String name = __o_name.Default(HX_HCSTRING("","\x00","\x00","\x00","\x00"));
::String value = __o_value.Default(HX_HCSTRING("","\x00","\x00","\x00","\x00"));
{
	HX_STACK_LINE(13)
	this->name = name;
	HX_STACK_LINE(14)
	this->value = value;
}
;
	return null();
}

//URLRequestHeader_obj::~URLRequestHeader_obj() { }

Dynamic URLRequestHeader_obj::__CreateEmpty() { return  new URLRequestHeader_obj; }
hx::ObjectPtr< URLRequestHeader_obj > URLRequestHeader_obj::__new(::String __o_name,::String __o_value)
{  hx::ObjectPtr< URLRequestHeader_obj > _result_ = new URLRequestHeader_obj();
	_result_->__construct(__o_name,__o_value);
	return _result_;}

Dynamic URLRequestHeader_obj::__Create(hx::DynamicArray inArgs)
{  hx::ObjectPtr< URLRequestHeader_obj > _result_ = new URLRequestHeader_obj();
	_result_->__construct(inArgs[0],inArgs[1]);
	return _result_;}


URLRequestHeader_obj::URLRequestHeader_obj()
{
}

void URLRequestHeader_obj::__Mark(HX_MARK_PARAMS)
{
	HX_MARK_BEGIN_CLASS(URLRequestHeader);
	HX_MARK_MEMBER_NAME(name,"name");
	HX_MARK_MEMBER_NAME(value,"value");
	HX_MARK_END_CLASS();
}

void URLRequestHeader_obj::__Visit(HX_VISIT_PARAMS)
{
	HX_VISIT_MEMBER_NAME(name,"name");
	HX_VISIT_MEMBER_NAME(value,"value");
}

Dynamic URLRequestHeader_obj::__Field(const ::String &inName,hx::PropertyAccess inCallProp)
{
	switch(inName.length) {
	case 4:
		if (HX_FIELD_EQ(inName,"name") ) { return name; }
		break;
	case 5:
		if (HX_FIELD_EQ(inName,"value") ) { return value; }
	}
	return super::__Field(inName,inCallProp);
}

Dynamic URLRequestHeader_obj::__SetField(const ::String &inName,const Dynamic &inValue,hx::PropertyAccess inCallProp)
{
	switch(inName.length) {
	case 4:
		if (HX_FIELD_EQ(inName,"name") ) { name=inValue.Cast< ::String >(); return inValue; }
		break;
	case 5:
		if (HX_FIELD_EQ(inName,"value") ) { value=inValue.Cast< ::String >(); return inValue; }
	}
	return super::__SetField(inName,inValue,inCallProp);
}

void URLRequestHeader_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_HCSTRING("name","\x4b","\x72","\xff","\x48"));
	outFields->push(HX_HCSTRING("value","\x71","\x7f","\xb8","\x31"));
	super::__GetFields(outFields);
};

#if HXCPP_SCRIPTABLE
static hx::StorageInfo sMemberStorageInfo[] = {
	{hx::fsString,(int)offsetof(URLRequestHeader_obj,name),HX_HCSTRING("name","\x4b","\x72","\xff","\x48")},
	{hx::fsString,(int)offsetof(URLRequestHeader_obj,value),HX_HCSTRING("value","\x71","\x7f","\xb8","\x31")},
	{ hx::fsUnknown, 0, null()}
};
static hx::StaticInfo *sStaticStorageInfo = 0;
#endif

static ::String sMemberFields[] = {
	HX_HCSTRING("name","\x4b","\x72","\xff","\x48"),
	HX_HCSTRING("value","\x71","\x7f","\xb8","\x31"),
	::String(null()) };

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(URLRequestHeader_obj::__mClass,"__mClass");
};

#ifdef HXCPP_VISIT_ALLOCS
static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(URLRequestHeader_obj::__mClass,"__mClass");
};

#endif

hx::Class URLRequestHeader_obj::__mClass;

void URLRequestHeader_obj::__register()
{
	hx::Static(__mClass) = new hx::Class_obj();
	__mClass->mName = HX_HCSTRING("lime.net.URLRequestHeader","\x97","\xe6","\x79","\x6b");
	__mClass->mSuper = &super::__SGetClass();
	__mClass->mConstructEmpty = &__CreateEmpty;
	__mClass->mConstructArgs = &__Create;
	__mClass->mGetStaticField = &hx::Class_obj::GetNoStaticField;
	__mClass->mSetStaticField = &hx::Class_obj::SetNoStaticField;
	__mClass->mMarkFunc = sMarkStatics;
	__mClass->mStatics = hx::Class_obj::dupFunctions(0 /* sStaticFields */);
	__mClass->mMembers = hx::Class_obj::dupFunctions(sMemberFields);
	__mClass->mCanCast = hx::TCanCast< URLRequestHeader_obj >;
#ifdef HXCPP_VISIT_ALLOCS
	__mClass->mVisitFunc = sVisitStatics;
#endif
#ifdef HXCPP_SCRIPTABLE
	__mClass->mMemberStorageInfo = sMemberStorageInfo;
#endif
#ifdef HXCPP_SCRIPTABLE
	__mClass->mStaticStorageInfo = sStaticStorageInfo;
#endif
	hx::RegisterClass(__mClass->mName, __mClass);
}

} // end namespace lime
Beispiel #19
0
hx::Val FlxSignal4_obj::__Field(const ::String &inName,hx::PropertyAccess inCallProp)
{
	switch(inName.length) {
	case 9:
		if (HX_FIELD_EQ(inName,"dispatch4") ) { return hx::Val( dispatch4_dyn()); }
	}
	return super::__Field(inName,inCallProp);
}

#if HXCPP_SCRIPTABLE
static hx::StorageInfo *FlxSignal4_obj_sMemberStorageInfo = 0;
static hx::StaticInfo *FlxSignal4_obj_sStaticStorageInfo = 0;
#endif

static ::String FlxSignal4_obj_sMemberFields[] = {
	HX_HCSTRING("dispatch4","\x3a","\x14","\xf1","\x78"),
	::String(null()) };

static void FlxSignal4_obj_sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(FlxSignal4_obj::__mClass,"__mClass");
};

#ifdef HXCPP_VISIT_ALLOCS
static void FlxSignal4_obj_sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(FlxSignal4_obj::__mClass,"__mClass");
};

#endif

hx::Class FlxSignal4_obj::__mClass;
Beispiel #20
0
void URLRequestHeader_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_HCSTRING("name","\x4b","\x72","\xff","\x48"));
	outFields->push(HX_HCSTRING("value","\x71","\x7f","\xb8","\x31"));
	super::__GetFields(outFields);
};
#ifdef HXCPP_VISIT_ALLOCS
static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(TouchEventType_Impl__obj::__mClass,"__mClass");
	HX_VISIT_MEMBER_NAME(TouchEventType_Impl__obj::te_unknown,"te_unknown");
	HX_VISIT_MEMBER_NAME(TouchEventType_Impl__obj::te_move,"te_move");
	HX_VISIT_MEMBER_NAME(TouchEventType_Impl__obj::te_down,"te_down");
	HX_VISIT_MEMBER_NAME(TouchEventType_Impl__obj::te_up,"te_up");
};

#endif

hx::Class TouchEventType_Impl__obj::__mClass;

static ::String sStaticFields[] = {
	HX_HCSTRING("te_unknown","\x7c","\x3b","\x30","\x76"),
	HX_HCSTRING("te_move","\xdf","\x3f","\x37","\x35"),
	HX_HCSTRING("te_down","\x30","\x55","\x44","\x2f"),
	HX_HCSTRING("te_up","\xa9","\x53","\x86","\x0d"),
	HX_HCSTRING("toString","\xac","\xd0","\x6e","\x38"),
	::String(null()) };

void TouchEventType_Impl__obj::__register()
{
	hx::Static(__mClass) = new hx::Class_obj();
	__mClass->mName = HX_HCSTRING("snow.types._Types.TouchEventType_Impl_","\xe9","\x93","\x39","\x8c");
	__mClass->mSuper = &super::__SGetClass();
	__mClass->mConstructEmpty = &__CreateEmpty;
	__mClass->mConstructArgs = &__Create;
	__mClass->mGetStaticField = &TouchEventType_Impl__obj::__GetStatic;
	__mClass->mSetStaticField = &hx::Class_obj::SetNoStaticField;
Beispiel #22
0
namespace audio1{


static ::String sMemberFields[] = {
	HX_HCSTRING("play","\xf4","\x2d","\x5a","\x4a"),
	HX_HCSTRING("pause","\xf6","\xd6","\x57","\xbd"),
	HX_HCSTRING("stop","\x02","\xf0","\x5b","\x4c"),
	HX_HCSTRING("length","\xe6","\x94","\x07","\x9f"),
	HX_HCSTRING("get_length","\xaf","\x04","\x8f","\x8f"),
	HX_HCSTRING("position","\xa9","\xa0","\xfa","\xca"),
	HX_HCSTRING("get_position","\xb2","\x54","\x14","\x80"),
	HX_HCSTRING("get_volume","\xa3","\x99","\xda","\x4f"),
	HX_HCSTRING("set_volume","\x17","\x38","\x58","\x53"),
	HX_HCSTRING("finished","\x72","\x93","\x0e","\x95"),
	HX_HCSTRING("get_finished","\x7b","\x47","\x28","\x4a"),
	::String(null()) };

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(AudioChannel_obj::__mClass,"__mClass");
};

#ifdef HXCPP_VISIT_ALLOCS
static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(AudioChannel_obj::__mClass,"__mClass");
};

#endif

hx::Class AudioChannel_obj::__mClass;

void AudioChannel_obj::__register()
{
	hx::Static(__mClass) = new hx::Class_obj();
	__mClass->mName = HX_HCSTRING("kha.audio1.AudioChannel","\x16","\x73","\xec","\xbd");
	__mClass->mSuper = &super::__SGetClass();
	__mClass->mMarkFunc = sMarkStatics;
	__mClass->mMembers = hx::Class_obj::dupFunctions(sMemberFields);
	__mClass->mCanCast = hx::TCanCast< AudioChannel_obj >;
#ifdef HXCPP_VISIT_ALLOCS
	__mClass->mVisitFunc = sVisitStatics;
#endif
	hx::RegisterClass(__mClass->mName, __mClass);
}

} // end namespace kha
void GraphicAuto_obj::__boot()
{
	resourceName= HX_HCSTRING("__ASSET__:bitmap_flixel_tile_GraphicAuto","\x23","\xe3","\xb5","\xf1");
}
Beispiel #24
0
static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(Mouse_obj::__mClass,"__mClass");
};

#ifdef HXCPP_VISIT_ALLOCS
static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(Mouse_obj::__mClass,"__mClass");
};

#endif

hx::Class Mouse_obj::__mClass;

static ::String sStaticFields[] = {
	HX_HCSTRING("hide","\xc2","\x34","\x0e","\x45"),
	HX_HCSTRING("show","\xfd","\xd4","\x52","\x4c"),
	::String(null()) };

void Mouse_obj::__register()
{
	hx::Static(__mClass) = new hx::Class_obj();
	__mClass->mName = HX_HCSTRING("openfl.ui.Mouse","\x09","\x85","\xe4","\x1f");
	__mClass->mSuper = &super::__SGetClass();
	__mClass->mConstructEmpty = &__CreateEmpty;
	__mClass->mConstructArgs = &__Create;
	__mClass->mGetStaticField = &Mouse_obj::__GetStatic;
	__mClass->mSetStaticField = &hx::Class_obj::SetNoStaticField;
	__mClass->mMarkFunc = sMarkStatics;
	__mClass->mStatics = hx::Class_obj::dupFunctions(sStaticFields);
	__mClass->mMembers = hx::Class_obj::dupFunctions(0 /* sMemberFields */);
Beispiel #25
0
void Error_obj::__boot()
{
Blocked = hx::CreateEnum< Error_obj >(HX_HCSTRING("Blocked","\xcc","\xa2","\x4f","\x12"),0,0);
OutsideBounds = hx::CreateEnum< Error_obj >(HX_HCSTRING("OutsideBounds","\x5a","\xc1","\x82","\x38"),2,0);
Overflow = hx::CreateEnum< Error_obj >(HX_HCSTRING("Overflow","\x62","\x9f","\xed","\x1a"),1,0);
}
namespace _Context3D{

Void SamplerState_obj::__construct()
{
HX_STACK_FRAME("openfl.display3D._Context3D.SamplerState","new",0xe10565af,"openfl.display3D._Context3D.SamplerState.new","openfl/display3D/Context3D.hx",1102,0xc899cbb9)
HX_STACK_THIS(this)
{
}
;
	return null();
}

//SamplerState_obj::~SamplerState_obj() { }

Dynamic SamplerState_obj::__CreateEmpty() { return  new SamplerState_obj; }
hx::ObjectPtr< SamplerState_obj > SamplerState_obj::__new()
{  hx::ObjectPtr< SamplerState_obj > _result_ = new SamplerState_obj();
	_result_->__construct();
	return _result_;}

Dynamic SamplerState_obj::__Create(hx::DynamicArray inArgs)
{  hx::ObjectPtr< SamplerState_obj > _result_ = new SamplerState_obj();
	_result_->__construct();
	return _result_;}


SamplerState_obj::SamplerState_obj()
{
}

void SamplerState_obj::__Mark(HX_MARK_PARAMS)
{
	HX_MARK_BEGIN_CLASS(SamplerState);
	HX_MARK_MEMBER_NAME(wrap,"wrap");
	HX_MARK_MEMBER_NAME(filter,"filter");
	HX_MARK_MEMBER_NAME(mipfilter,"mipfilter");
	HX_MARK_END_CLASS();
}

void SamplerState_obj::__Visit(HX_VISIT_PARAMS)
{
	HX_VISIT_MEMBER_NAME(wrap,"wrap");
	HX_VISIT_MEMBER_NAME(filter,"filter");
	HX_VISIT_MEMBER_NAME(mipfilter,"mipfilter");
}

Dynamic SamplerState_obj::__Field(const ::String &inName,hx::PropertyAccess inCallProp)
{
	switch(inName.length) {
	case 4:
		if (HX_FIELD_EQ(inName,"wrap") ) { return wrap; }
		break;
	case 6:
		if (HX_FIELD_EQ(inName,"filter") ) { return filter; }
		break;
	case 9:
		if (HX_FIELD_EQ(inName,"mipfilter") ) { return mipfilter; }
	}
	return super::__Field(inName,inCallProp);
}

Dynamic SamplerState_obj::__SetField(const ::String &inName,const Dynamic &inValue,hx::PropertyAccess inCallProp)
{
	switch(inName.length) {
	case 4:
		if (HX_FIELD_EQ(inName,"wrap") ) { wrap=inValue.Cast< ::openfl::display3D::Context3DWrapMode >(); return inValue; }
		break;
	case 6:
		if (HX_FIELD_EQ(inName,"filter") ) { filter=inValue.Cast< ::openfl::display3D::Context3DTextureFilter >(); return inValue; }
		break;
	case 9:
		if (HX_FIELD_EQ(inName,"mipfilter") ) { mipfilter=inValue.Cast< ::openfl::display3D::Context3DMipFilter >(); return inValue; }
	}
	return super::__SetField(inName,inValue,inCallProp);
}

void SamplerState_obj::__GetFields(Array< ::String> &outFields)
{
	outFields->push(HX_HCSTRING("wrap","\xca","\x39","\xff","\x4e"));
	outFields->push(HX_HCSTRING("filter","\xb8","\x1f","\x35","\x85"));
	outFields->push(HX_HCSTRING("mipfilter","\x4c","\x98","\x13","\xfd"));
	super::__GetFields(outFields);
};

#if HXCPP_SCRIPTABLE
static hx::StorageInfo sMemberStorageInfo[] = {
	{hx::fsObject /*::openfl::display3D::Context3DWrapMode*/ ,(int)offsetof(SamplerState_obj,wrap),HX_HCSTRING("wrap","\xca","\x39","\xff","\x4e")},
	{hx::fsObject /*::openfl::display3D::Context3DTextureFilter*/ ,(int)offsetof(SamplerState_obj,filter),HX_HCSTRING("filter","\xb8","\x1f","\x35","\x85")},
	{hx::fsObject /*::openfl::display3D::Context3DMipFilter*/ ,(int)offsetof(SamplerState_obj,mipfilter),HX_HCSTRING("mipfilter","\x4c","\x98","\x13","\xfd")},
	{ hx::fsUnknown, 0, null()}
};
static hx::StaticInfo *sStaticStorageInfo = 0;
#endif

static ::String sMemberFields[] = {
	HX_HCSTRING("wrap","\xca","\x39","\xff","\x4e"),
	HX_HCSTRING("filter","\xb8","\x1f","\x35","\x85"),
	HX_HCSTRING("mipfilter","\x4c","\x98","\x13","\xfd"),
	::String(null()) };

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(SamplerState_obj::__mClass,"__mClass");
};

#ifdef HXCPP_VISIT_ALLOCS
static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(SamplerState_obj::__mClass,"__mClass");
};

#endif

hx::Class SamplerState_obj::__mClass;

void SamplerState_obj::__register()
{
	hx::Static(__mClass) = new hx::Class_obj();
	__mClass->mName = HX_HCSTRING("openfl.display3D._Context3D.SamplerState","\x3d","\x62","\x7f","\xb2");
	__mClass->mSuper = &super::__SGetClass();
	__mClass->mConstructEmpty = &__CreateEmpty;
	__mClass->mConstructArgs = &__Create;
	__mClass->mGetStaticField = &hx::Class_obj::GetNoStaticField;
	__mClass->mSetStaticField = &hx::Class_obj::SetNoStaticField;
	__mClass->mMarkFunc = sMarkStatics;
	__mClass->mStatics = hx::Class_obj::dupFunctions(0 /* sStaticFields */);
	__mClass->mMembers = hx::Class_obj::dupFunctions(sMemberFields);
	__mClass->mCanCast = hx::TCanCast< SamplerState_obj >;
#ifdef HXCPP_VISIT_ALLOCS
	__mClass->mVisitFunc = sVisitStatics;
#endif
#ifdef HXCPP_SCRIPTABLE
	__mClass->mMemberStorageInfo = sMemberStorageInfo;
#endif
#ifdef HXCPP_SCRIPTABLE
	__mClass->mStaticStorageInfo = sStaticStorageInfo;
#endif
	hx::RegisterClass(__mClass->mName, __mClass);
}

} // end namespace openfl
	return false;
}

bool GraphicVirtualInput_obj::__SetStatic(const ::String &inName,Dynamic &ioValue,hx::PropertyAccess inCallProp)
{
	switch(inName.length) {
	case 12:
		if (HX_FIELD_EQ(inName,"resourceName") ) { resourceName=ioValue.Cast< ::String >(); return true; }
	}
	return false;
}

#if HXCPP_SCRIPTABLE
static hx::StorageInfo *sMemberStorageInfo = 0;
static hx::StaticInfo sStaticStorageInfo[] = {
	{hx::fsString,(void *) &GraphicVirtualInput_obj::resourceName,HX_HCSTRING("resourceName","\x39","\x7a","\x62","\x90")},
	{ hx::fsUnknown, 0, null()}
};
#endif

static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(GraphicVirtualInput_obj::__mClass,"__mClass");
	HX_MARK_MEMBER_NAME(GraphicVirtualInput_obj::resourceName,"resourceName");
};

#ifdef HXCPP_VISIT_ALLOCS
static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(GraphicVirtualInput_obj::__mClass,"__mClass");
	HX_VISIT_MEMBER_NAME(GraphicVirtualInput_obj::resourceName,"resourceName");
};
Beispiel #28
0
		if (HX_FIELD_EQ(inName,"_trace") ) { return hx::Val( _trace_dyn()); }
		if (HX_FIELD_EQ(inName,"_print") ) { return hx::Val( _print_dyn()); }
		break;
	case 8:
		if (HX_FIELD_EQ(inName,"_handler") ) { return hx::Val( _handler_dyn()); }
	}
	return super::__Field(inName,inCallProp);
}

#if HXCPP_SCRIPTABLE
static hx::StorageInfo *PrintReport_obj_sMemberStorageInfo = 0;
static hx::StaticInfo *PrintReport_obj_sStaticStorageInfo = 0;
#endif

static ::String PrintReport_obj_sMemberFields[] = {
	HX_HCSTRING("_handler","\x4b","\x09","\x8e","\x7f"),
	HX_HCSTRING("_trace","\xc6","\xd5","\x06","\x12"),
	HX_HCSTRING("_print","\x6e","\x9f","\x72","\xc4"),
	::String(null()) };

static void PrintReport_obj_sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(PrintReport_obj::__mClass,"__mClass");
};

#ifdef HXCPP_VISIT_ALLOCS
static void PrintReport_obj_sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(PrintReport_obj::__mClass,"__mClass");
};

#endif
	HX_VISIT_MEMBER_NAME(WindowEventType_Impl__obj::we_minimized,"we_minimized");
	HX_VISIT_MEMBER_NAME(WindowEventType_Impl__obj::we_maximized,"we_maximized");
	HX_VISIT_MEMBER_NAME(WindowEventType_Impl__obj::we_restored,"we_restored");
	HX_VISIT_MEMBER_NAME(WindowEventType_Impl__obj::we_enter,"we_enter");
	HX_VISIT_MEMBER_NAME(WindowEventType_Impl__obj::we_leave,"we_leave");
	HX_VISIT_MEMBER_NAME(WindowEventType_Impl__obj::we_focus_gained,"we_focus_gained");
	HX_VISIT_MEMBER_NAME(WindowEventType_Impl__obj::we_focus_lost,"we_focus_lost");
	HX_VISIT_MEMBER_NAME(WindowEventType_Impl__obj::we_close,"we_close");
};

#endif

hx::Class WindowEventType_Impl__obj::__mClass;

static ::String sStaticFields[] = {
	HX_HCSTRING("we_unknown","\x19","\xa3","\x0f","\xb7"),
	HX_HCSTRING("we_shown","\xa0","\xb6","\x79","\x76"),
	HX_HCSTRING("we_hidden","\xbb","\xe6","\x2b","\x5a"),
	HX_HCSTRING("we_exposed","\x2f","\xe9","\xf6","\xfe"),
	HX_HCSTRING("we_moved","\x02","\xfa","\xb7","\x06"),
	HX_HCSTRING("we_resized","\x7f","\xdb","\x07","\x39"),
	HX_HCSTRING("we_size_changed","\x47","\x8e","\x40","\x39"),
	HX_HCSTRING("we_minimized","\xd5","\xbc","\xfc","\xeb"),
	HX_HCSTRING("we_maximized","\x67","\xcf","\x3f","\xc2"),
	HX_HCSTRING("we_restored","\xe7","\x1a","\x05","\xfc"),
	HX_HCSTRING("we_enter","\xe7","\x9a","\xd8","\x6a"),
	HX_HCSTRING("we_leave","\xc6","\x62","\xa5","\x6c"),
	HX_HCSTRING("we_focus_gained","\x76","\x3d","\x1b","\x38"),
	HX_HCSTRING("we_focus_lost","\xbc","\x5a","\x87","\x59"),
	HX_HCSTRING("we_close","\x87","\x45","\xb5","\x42"),
	HX_HCSTRING("toString","\xac","\xd0","\x6e","\x38"),
Beispiel #30
0
static void sMarkStatics(HX_MARK_PARAMS) {
	HX_MARK_MEMBER_NAME(Lib_obj::__mClass,"__mClass");
};

#ifdef HXCPP_VISIT_ALLOCS
static void sVisitStatics(HX_VISIT_PARAMS) {
	HX_VISIT_MEMBER_NAME(Lib_obj::__mClass,"__mClass");
};

#endif

hx::Class Lib_obj::__mClass;

static ::String sStaticFields[] = {
	HX_HCSTRING("load","\x26","\x9a","\xb7","\x47"),
	::String(null()) };

void Lib_obj::__register()
{
	hx::Static(__mClass) = new hx::Class_obj();
	__mClass->mName = HX_HCSTRING("cpp.Lib","\x5a","\x26","\x48","\x78");
	__mClass->mSuper = &super::__SGetClass();
	__mClass->mConstructEmpty = &__CreateEmpty;
	__mClass->mConstructArgs = &__Create;
	__mClass->mGetStaticField = &Lib_obj::__GetStatic;
	__mClass->mSetStaticField = &hx::Class_obj::SetNoStaticField;
	__mClass->mMarkFunc = sMarkStatics;
	__mClass->mStatics = hx::Class_obj::dupFunctions(sStaticFields);
	__mClass->mMembers = hx::Class_obj::dupFunctions(0 /* sMemberFields */);
	__mClass->mCanCast = hx::TCanCast< Lib_obj >;