First commit

hGameTest/bin/linux/obj/include/lime/system/CFFI.h

@@ -0,0 +1,83 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system_CFFI
+#define INCLUDED_lime_system_CFFI
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(lime,_hx_system,CFFI)
+
+namespace lime{
+namespace _hx_system{
+
+
+class HXCPP_CLASS_ATTRIBUTES CFFI_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef CFFI_obj OBJ_;
+		CFFI_obj();
+
+	public:
+		enum { _hx_ClassId = 0x68c2f22a };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.system.CFFI")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"lime.system.CFFI"); }
+
+		inline static hx::ObjectPtr< CFFI_obj > __new() {
+			hx::ObjectPtr< CFFI_obj > __this = new CFFI_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< CFFI_obj > __alloc(hx::Ctx *_hx_ctx) {
+			CFFI_obj *__this = (CFFI_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CFFI_obj), false, "lime.system.CFFI"));
+			*(void **)__this = CFFI_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~CFFI_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		static void __init__();
+
+		::String __ToString() const { return HX_("CFFI",a6,a6,7e,2c); }
+
+		static void __boot();
+		static  ::haxe::ds::StringMap _hx___moduleNames;
+		static bool available;
+		static bool enabled;
+		static  ::Dynamic load(::String library,::String method,hx::Null< int >  args,hx::Null< bool >  lazy);
+		static ::Dynamic load_dyn();
+
+		static ::String _hx___findHaxelib(::String library);
+		static ::Dynamic _hx___findHaxelib_dyn();
+
+		static void _hx___loaderTrace(::String message);
+		static ::Dynamic _hx___loaderTrace_dyn();
+
+		static ::String _hx___sysName();
+		static ::Dynamic _hx___sysName_dyn();
+
+		static  ::Dynamic _hx___tryLoad(::String name,::String library,::String func,int args);
+		static ::Dynamic _hx___tryLoad_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace system
+
+#endif /* INCLUDED_lime_system_CFFI */ 

hGameTest/bin/linux/obj/include/lime/system/Clipboard.h

@@ -0,0 +1,73 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system_Clipboard
+#define INCLUDED_lime_system_Clipboard
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Void_Void)
+HX_DECLARE_CLASS2(lime,_hx_system,Clipboard)
+
+namespace lime{
+namespace _hx_system{
+
+
+class HXCPP_CLASS_ATTRIBUTES Clipboard_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Clipboard_obj OBJ_;
+		Clipboard_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3c11bbb2 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.system.Clipboard")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"lime.system.Clipboard"); }
+
+		inline static hx::ObjectPtr< Clipboard_obj > __new() {
+			hx::ObjectPtr< Clipboard_obj > __this = new Clipboard_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Clipboard_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Clipboard_obj *__this = (Clipboard_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Clipboard_obj), false, "lime.system.Clipboard"));
+			*(void **)__this = Clipboard_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Clipboard_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Clipboard",b6,45,aa,e3); }
+
+		static void __boot();
+		static  ::lime::app::_Event_Void_Void onUpdate;
+		static ::String _text;
+		static void _hx___update();
+		static ::Dynamic _hx___update_dyn();
+
+		static ::String get_text();
+		static ::Dynamic get_text_dyn();
+
+		static ::String set_text(::String value);
+		static ::Dynamic set_text_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace system
+
+#endif /* INCLUDED_lime_system_Clipboard */ 

hGameTest/bin/linux/obj/include/lime/system/Display.h

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system_Display
+#define INCLUDED_lime_system_Display
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_84dc687d4538b090_38_new)
+HX_DECLARE_CLASS2(lime,math,Rectangle)
+HX_DECLARE_CLASS2(lime,_hx_system,Display)
+HX_DECLARE_CLASS2(lime,_hx_system,DisplayMode)
+
+namespace lime{
+namespace _hx_system{
+
+
+class HXCPP_CLASS_ATTRIBUTES Display_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Display_obj OBJ_;
+		Display_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3918111e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.system.Display")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"lime.system.Display"); }
+
+		inline static hx::ObjectPtr< Display_obj > __new() {
+			hx::ObjectPtr< Display_obj > __this = new Display_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Display_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Display_obj *__this = (Display_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Display_obj), true, "lime.system.Display"));
+			*(void **)__this = Display_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_84dc687d4538b090_38_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Display_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Display",22,52,9b,88); }
+
+		 ::lime::math::Rectangle bounds;
+		 ::lime::_hx_system::DisplayMode currentMode;
+		int id;
+		Float dpi;
+		::String name;
+		::Array< ::Dynamic> supportedModes;
+};
+
+} // end namespace lime
+} // end namespace system
+
+#endif /* INCLUDED_lime_system_Display */ 

hGameTest/bin/linux/obj/include/lime/system/DisplayMode.h

@@ -0,0 +1,74 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system_DisplayMode
+#define INCLUDED_lime_system_DisplayMode
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_bad5236c57cf1a4a_32_new)
+HX_DECLARE_CLASS2(lime,_hx_system,DisplayMode)
+
+namespace lime{
+namespace _hx_system{
+
+
+class HXCPP_CLASS_ATTRIBUTES DisplayMode_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef DisplayMode_obj OBJ_;
+		DisplayMode_obj();
+
+	public:
+		enum { _hx_ClassId = 0x600bc2bd };
+
+		void __construct(int width,int height,int refreshRate,int pixelFormat);
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.system.DisplayMode")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"lime.system.DisplayMode"); }
+
+		inline static hx::ObjectPtr< DisplayMode_obj > __new(int width,int height,int refreshRate,int pixelFormat) {
+			hx::ObjectPtr< DisplayMode_obj > __this = new DisplayMode_obj();
+			__this->__construct(width,height,refreshRate,pixelFormat);
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< DisplayMode_obj > __alloc(hx::Ctx *_hx_ctx,int width,int height,int refreshRate,int pixelFormat) {
+			DisplayMode_obj *__this = (DisplayMode_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(DisplayMode_obj), false, "lime.system.DisplayMode"));
+			*(void **)__this = DisplayMode_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_bad5236c57cf1a4a_32_new)
+HXLINE(  33)		( ( ::lime::_hx_system::DisplayMode)(__this) )->width = width;
+HXLINE(  34)		( ( ::lime::_hx_system::DisplayMode)(__this) )->height = height;
+HXLINE(  35)		( ( ::lime::_hx_system::DisplayMode)(__this) )->refreshRate = refreshRate;
+HXLINE(  36)		( ( ::lime::_hx_system::DisplayMode)(__this) )->pixelFormat = pixelFormat;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DisplayMode_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("DisplayMode",a5,0a,86,14); }
+
+		int height;
+		int pixelFormat;
+		int refreshRate;
+		int width;
+};
+
+} // end namespace lime
+} // end namespace system
+
+#endif /* INCLUDED_lime_system_DisplayMode */ 

hGameTest/bin/linux/obj/include/lime/system/Endian.h

@@ -0,0 +1,37 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system_Endian
+#define INCLUDED_lime_system_Endian
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,_hx_system,Endian)
+namespace lime{
+namespace _hx_system{
+
+
+class Endian_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef Endian_obj OBJ_;
+
+	public:
+		Endian_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("lime.system.Endian",41,85,63,b4); }
+		::String __ToString() const { return HX_("Endian.",13,17,4e,0a) + _hx_tag; }
+
+		static ::lime::_hx_system::Endian _hx_BIG_ENDIAN;
+		static inline ::lime::_hx_system::Endian _hx_BIG_ENDIAN_dyn() { return _hx_BIG_ENDIAN; }
+		static ::lime::_hx_system::Endian _hx_LITTLE_ENDIAN;
+		static inline ::lime::_hx_system::Endian _hx_LITTLE_ENDIAN_dyn() { return _hx_LITTLE_ENDIAN; }
+};
+
+} // end namespace lime
+} // end namespace system
+
+#endif /* INCLUDED_lime_system_Endian */ 

hGameTest/bin/linux/obj/include/lime/system/JNI.h

@@ -0,0 +1,97 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system_JNI
+#define INCLUDED_lime_system_JNI
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(lime,_hx_system,JNI)
+HX_DECLARE_CLASS2(lime,_hx_system,JNIMemberField)
+HX_DECLARE_CLASS2(lime,_hx_system,JNIStaticField)
+
+namespace lime{
+namespace _hx_system{
+
+
+class HXCPP_CLASS_ATTRIBUTES JNI_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef JNI_obj OBJ_;
+		JNI_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0e3c4b1d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.system.JNI")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"lime.system.JNI"); }
+
+		inline static hx::ObjectPtr< JNI_obj > __new() {
+			hx::ObjectPtr< JNI_obj > __this = new JNI_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< JNI_obj > __alloc(hx::Ctx *_hx_ctx) {
+			JNI_obj *__this = (JNI_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(JNI_obj), false, "lime.system.JNI"));
+			*(void **)__this = JNI_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~JNI_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JNI",05,6b,38,00); }
+
+		static void __boot();
+		static  ::haxe::ds::StringMap alreadyCreated;
+		static bool initialized;
+		static  ::Dynamic callMember( ::Dynamic method, ::Dynamic jobject,::cpp::VirtualArray a);
+		static ::Dynamic callMember_dyn();
+
+		static  ::Dynamic callStatic( ::Dynamic method,::cpp::VirtualArray a);
+		static ::Dynamic callStatic_dyn();
+
+		static  ::lime::_hx_system::JNIMemberField createMemberField(::String className,::String memberName,::String signature);
+		static ::Dynamic createMemberField_dyn();
+
+		static  ::Dynamic createMemberMethod(::String className,::String memberName,::String signature,hx::Null< bool >  useArray,hx::Null< bool >  quietFail);
+		static ::Dynamic createMemberMethod_dyn();
+
+		static  ::lime::_hx_system::JNIStaticField createStaticField(::String className,::String memberName,::String signature);
+		static ::Dynamic createStaticField_dyn();
+
+		static  ::Dynamic createStaticMethod(::String className,::String memberName,::String signature,hx::Null< bool >  useArray,hx::Null< bool >  quietFail);
+		static ::Dynamic createStaticMethod_dyn();
+
+		static  ::Dynamic getEnv();
+		static ::Dynamic getEnv_dyn();
+
+		static void init();
+		static ::Dynamic init_dyn();
+
+		static  ::Dynamic onCallback( ::Dynamic object,::String method,::cpp::VirtualArray args);
+		static ::Dynamic onCallback_dyn();
+
+		static void postUICallback( ::Dynamic callback);
+		static ::Dynamic postUICallback_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace system
+
+#endif /* INCLUDED_lime_system_JNI */ 

hGameTest/bin/linux/obj/include/lime/system/JNIMemberField.h

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system_JNIMemberField
+#define INCLUDED_lime_system_JNIMemberField
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_6a03f50885e20814_200_new)
+HX_DECLARE_CLASS2(lime,_hx_system,JNIMemberField)
+
+namespace lime{
+namespace _hx_system{
+
+
+class HXCPP_CLASS_ATTRIBUTES JNIMemberField_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef JNIMemberField_obj OBJ_;
+		JNIMemberField_obj();
+
+	public:
+		enum { _hx_ClassId = 0x21350247 };
+
+		void __construct( ::Dynamic field);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.system.JNIMemberField")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"lime.system.JNIMemberField"); }
+
+		inline static hx::ObjectPtr< JNIMemberField_obj > __new( ::Dynamic field) {
+			hx::ObjectPtr< JNIMemberField_obj > __this = new JNIMemberField_obj();
+			__this->__construct(field);
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< JNIMemberField_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic field) {
+			JNIMemberField_obj *__this = (JNIMemberField_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(JNIMemberField_obj), true, "lime.system.JNIMemberField"));
+			*(void **)__this = JNIMemberField_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_6a03f50885e20814_200_new)
+HXDLIN( 200)		( ( ::lime::_hx_system::JNIMemberField)(__this) )->field = field;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~JNIMemberField_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JNIMemberField",fb,8c,1f,2d); }
+
+		 ::Dynamic field;
+		 ::Dynamic get( ::Dynamic jobject);
+		::Dynamic get_dyn();
+
+		 ::Dynamic set( ::Dynamic jobject, ::Dynamic value);
+		::Dynamic set_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace system
+
+#endif /* INCLUDED_lime_system_JNIMemberField */ 

hGameTest/bin/linux/obj/include/lime/system/JNIMethod.h

@@ -0,0 +1,65 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system_JNIMethod
+#define INCLUDED_lime_system_JNIMethod
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,_hx_system,JNIMethod)
+
+namespace lime{
+namespace _hx_system{
+
+
+class HXCPP_CLASS_ATTRIBUTES JNIMethod_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef JNIMethod_obj OBJ_;
+		JNIMethod_obj();
+
+	public:
+		enum { _hx_ClassId = 0x20e469de };
+
+		void __construct( ::Dynamic method);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.system.JNIMethod")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"lime.system.JNIMethod"); }
+		static hx::ObjectPtr< JNIMethod_obj > __new( ::Dynamic method);
+		static hx::ObjectPtr< JNIMethod_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic method);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~JNIMethod_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JNIMethod",c6,67,b5,80); }
+
+		 ::Dynamic method;
+		 ::Dynamic callMember(::cpp::VirtualArray args);
+		::Dynamic callMember_dyn();
+
+		 ::Dynamic callStatic(::cpp::VirtualArray args);
+		::Dynamic callStatic_dyn();
+
+		 ::Dynamic getMemberMethod(bool useArray);
+		::Dynamic getMemberMethod_dyn();
+
+		 ::Dynamic getStaticMethod(bool useArray);
+		::Dynamic getStaticMethod_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace system
+
+#endif /* INCLUDED_lime_system_JNIMethod */ 

hGameTest/bin/linux/obj/include/lime/system/JNIStaticField.h

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system_JNIStaticField
+#define INCLUDED_lime_system_JNIStaticField
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_241b089bf20ccbef_232_new)
+HX_DECLARE_CLASS2(lime,_hx_system,JNIStaticField)
+
+namespace lime{
+namespace _hx_system{
+
+
+class HXCPP_CLASS_ATTRIBUTES JNIStaticField_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef JNIStaticField_obj OBJ_;
+		JNIStaticField_obj();
+
+	public:
+		enum { _hx_ClassId = 0x33ff1773 };
+
+		void __construct( ::Dynamic field);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.system.JNIStaticField")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"lime.system.JNIStaticField"); }
+
+		inline static hx::ObjectPtr< JNIStaticField_obj > __new( ::Dynamic field) {
+			hx::ObjectPtr< JNIStaticField_obj > __this = new JNIStaticField_obj();
+			__this->__construct(field);
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< JNIStaticField_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic field) {
+			JNIStaticField_obj *__this = (JNIStaticField_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(JNIStaticField_obj), true, "lime.system.JNIStaticField"));
+			*(void **)__this = JNIStaticField_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_241b089bf20ccbef_232_new)
+HXDLIN( 232)		( ( ::lime::_hx_system::JNIStaticField)(__this) )->field = field;
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~JNIStaticField_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("JNIStaticField",27,a2,e9,3f); }
+
+		 ::Dynamic field;
+		 ::Dynamic get();
+		::Dynamic get_dyn();
+
+		 ::Dynamic set( ::Dynamic value);
+		::Dynamic set_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace system
+
+#endif /* INCLUDED_lime_system_JNIStaticField */ 

hGameTest/bin/linux/obj/include/lime/system/Sensor.h

@@ -0,0 +1,70 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system_Sensor
+#define INCLUDED_lime_system_Sensor
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+HX_DECLARE_CLASS2(lime,app,_Event_Float_Float_Float_Void)
+HX_DECLARE_CLASS2(lime,_hx_system,Sensor)
+HX_DECLARE_CLASS2(lime,_hx_system,SensorType)
+
+namespace lime{
+namespace _hx_system{
+
+
+class HXCPP_CLASS_ATTRIBUTES Sensor_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Sensor_obj OBJ_;
+		Sensor_obj();
+
+	public:
+		enum { _hx_ClassId = 0x15a9e542 };
+
+		void __construct( ::lime::_hx_system::SensorType type,int id);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.system.Sensor")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"lime.system.Sensor"); }
+		static hx::ObjectPtr< Sensor_obj > __new( ::lime::_hx_system::SensorType type,int id);
+		static hx::ObjectPtr< Sensor_obj > __alloc(hx::Ctx *_hx_ctx, ::lime::_hx_system::SensorType type,int id);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Sensor_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Sensor",5a,a6,24,a0); }
+
+		static void __boot();
+		static  ::haxe::ds::IntMap sensorByID;
+		static ::Array< ::Dynamic> sensors;
+		static ::Array< ::Dynamic> getSensors( ::lime::_hx_system::SensorType type);
+		static ::Dynamic getSensors_dyn();
+
+		static  ::lime::_hx_system::Sensor registerSensor( ::lime::_hx_system::SensorType type,int id);
+		static ::Dynamic registerSensor_dyn();
+
+		int id;
+		 ::lime::app::_Event_Float_Float_Float_Void onUpdate;
+		 ::lime::_hx_system::SensorType type;
+};
+
+} // end namespace lime
+} // end namespace system
+
+#endif /* INCLUDED_lime_system_Sensor */ 

hGameTest/bin/linux/obj/include/lime/system/SensorType.h

@@ -0,0 +1,35 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system_SensorType
+#define INCLUDED_lime_system_SensorType
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,_hx_system,SensorType)
+namespace lime{
+namespace _hx_system{
+
+
+class SensorType_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef SensorType_obj OBJ_;
+
+	public:
+		SensorType_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("lime.system.SensorType",ba,2d,f6,ed); }
+		::String __ToString() const { return HX_("SensorType.",7a,f3,58,45) + _hx_tag; }
+
+		static ::lime::_hx_system::SensorType ACCELEROMETER;
+		static inline ::lime::_hx_system::SensorType ACCELEROMETER_dyn() { return ACCELEROMETER; }
+};
+
+} // end namespace lime
+} // end namespace system
+
+#endif /* INCLUDED_lime_system_SensorType */ 

hGameTest/bin/linux/obj/include/lime/system/System.h

@@ -0,0 +1,162 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system_System
+#define INCLUDED_lime_system_System
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(lime,_hx_system,Display)
+HX_DECLARE_CLASS2(lime,_hx_system,Endian)
+HX_DECLARE_CLASS2(lime,_hx_system,System)
+
+namespace lime{
+namespace _hx_system{
+
+
+class HXCPP_CLASS_ATTRIBUTES System_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef System_obj OBJ_;
+		System_obj();
+
+	public:
+		enum { _hx_ClassId = 0x36083f93 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.system.System")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"lime.system.System"); }
+
+		inline static hx::ObjectPtr< System_obj > __new() {
+			hx::ObjectPtr< System_obj > __this = new System_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< System_obj > __alloc(hx::Ctx *_hx_ctx) {
+			System_obj *__this = (System_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(System_obj), false, "lime.system.System"));
+			*(void **)__this = System_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~System_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("System",0f,0b,77,27); }
+
+		static void __boot();
+		static bool disableCFFI;
+		static ::String _hx___applicationDirectory;
+		static  ::haxe::ds::StringMap _hx___applicationEntryPoint;
+		static ::String _hx___applicationStorageDirectory;
+		static ::String _hx___desktopDirectory;
+		static ::String _hx___deviceModel;
+		static ::String _hx___deviceVendor;
+		static  ::haxe::ds::IntMap _hx___directories;
+		static ::String _hx___documentsDirectory;
+		static  ::lime::_hx_system::Endian _hx___endianness;
+		static ::String _hx___fontsDirectory;
+		static ::String _hx___platformLabel;
+		static ::String _hx___platformName;
+		static ::String _hx___platformVersion;
+		static ::String _hx___userDirectory;
+		static void exit(int code);
+		static ::Dynamic exit_dyn();
+
+		static  ::lime::_hx_system::Display getDisplay(int id);
+		static ::Dynamic getDisplay_dyn();
+
+		static int getTimer();
+		static ::Dynamic getTimer_dyn();
+
+		static  ::Dynamic load(::String library,::String method,hx::Null< int >  args,hx::Null< bool >  lazy);
+		static ::Dynamic load_dyn();
+
+		static void openFile(::String path);
+		static ::Dynamic openFile_dyn();
+
+		static void openURL(::String url,::String target);
+		static ::Dynamic openURL_dyn();
+
+		static void _hx___copyMissingFields( ::Dynamic target, ::Dynamic source);
+		static ::Dynamic _hx___copyMissingFields_dyn();
+
+		static ::String _hx___getDirectory(int type);
+		static ::Dynamic _hx___getDirectory_dyn();
+
+		static void _hx___parseArguments( ::Dynamic attributes);
+		static ::Dynamic _hx___parseArguments_dyn();
+
+		static bool _hx___parseBool(::String value);
+		static ::Dynamic _hx___parseBool_dyn();
+
+		static void _hx___registerEntryPoint(::String projectName, ::Dynamic entryPoint);
+		static ::Dynamic _hx___registerEntryPoint_dyn();
+
+		static ::String _hx___runProcess(::String command,::Array< ::String > args);
+		static ::Dynamic _hx___runProcess_dyn();
+
+		static bool get_allowScreenTimeout();
+		static ::Dynamic get_allowScreenTimeout_dyn();
+
+		static bool set_allowScreenTimeout(bool value);
+		static ::Dynamic set_allowScreenTimeout_dyn();
+
+		static ::String get_applicationDirectory();
+		static ::Dynamic get_applicationDirectory_dyn();
+
+		static ::String get_applicationStorageDirectory();
+		static ::Dynamic get_applicationStorageDirectory_dyn();
+
+		static ::String get_deviceModel();
+		static ::Dynamic get_deviceModel_dyn();
+
+		static ::String get_deviceVendor();
+		static ::Dynamic get_deviceVendor_dyn();
+
+		static ::String get_desktopDirectory();
+		static ::Dynamic get_desktopDirectory_dyn();
+
+		static ::String get_documentsDirectory();
+		static ::Dynamic get_documentsDirectory_dyn();
+
+		static  ::lime::_hx_system::Endian get_endianness();
+		static ::Dynamic get_endianness_dyn();
+
+		static ::String get_fontsDirectory();
+		static ::Dynamic get_fontsDirectory_dyn();
+
+		static int get_numDisplays();
+		static ::Dynamic get_numDisplays_dyn();
+
+		static ::String get_platformLabel();
+		static ::Dynamic get_platformLabel_dyn();
+
+		static ::String get_platformName();
+		static ::Dynamic get_platformName_dyn();
+
+		static ::String get_platformVersion();
+		static ::Dynamic get_platformVersion_dyn();
+
+		static ::String get_userDirectory();
+		static ::Dynamic get_userDirectory_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace system
+
+#endif /* INCLUDED_lime_system_System */ 

hGameTest/bin/linux/obj/include/lime/system/ThreadPool.h

@@ -0,0 +1,88 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system_ThreadPool
+#define INCLUDED_lime_system_ThreadPool
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Dynamic_Void)
+HX_DECLARE_CLASS2(lime,_hx_system,ThreadPool)
+HX_DECLARE_CLASS2(sys,thread,Deque)
+
+namespace lime{
+namespace _hx_system{
+
+
+class HXCPP_CLASS_ATTRIBUTES ThreadPool_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ThreadPool_obj OBJ_;
+		ThreadPool_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3ef61f6a };
+
+		void __construct(hx::Null< int >  __o_minThreads,hx::Null< int >  __o_maxThreads);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.system.ThreadPool")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"lime.system.ThreadPool"); }
+		static hx::ObjectPtr< ThreadPool_obj > __new(hx::Null< int >  __o_minThreads,hx::Null< int >  __o_maxThreads);
+		static hx::ObjectPtr< ThreadPool_obj > __alloc(hx::Ctx *_hx_ctx,hx::Null< int >  __o_minThreads,hx::Null< int >  __o_maxThreads);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ThreadPool_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ThreadPool",e6,58,d6,3c); }
+
+		int currentThreads;
+		 ::lime::app::_Event_Dynamic_Void doWork;
+		int maxThreads;
+		int minThreads;
+		 ::lime::app::_Event_Dynamic_Void onComplete;
+		 ::lime::app::_Event_Dynamic_Void onError;
+		 ::lime::app::_Event_Dynamic_Void onProgress;
+		 ::lime::app::_Event_Dynamic_Void onRun;
+		bool _hx___synchronous;
+		int _hx___workCompleted;
+		 ::sys::thread::Deque _hx___workIncoming;
+		int _hx___workQueued;
+		 ::sys::thread::Deque _hx___workResult;
+		void queue( ::Dynamic state);
+		::Dynamic queue_dyn();
+
+		void sendComplete( ::Dynamic state);
+		::Dynamic sendComplete_dyn();
+
+		void sendError( ::Dynamic state);
+		::Dynamic sendError_dyn();
+
+		void sendProgress( ::Dynamic state);
+		::Dynamic sendProgress_dyn();
+
+		void runWork( ::Dynamic state);
+		::Dynamic runWork_dyn();
+
+		void _hx___doWork();
+		::Dynamic _hx___doWork_dyn();
+
+		void _hx___update(int deltaTime);
+		::Dynamic _hx___update_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace system
+
+#endif /* INCLUDED_lime_system_ThreadPool */ 

hGameTest/bin/linux/obj/include/lime/system/_CFFIPointer/CFFIPointer_Impl_.h

@@ -0,0 +1,103 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system__CFFIPointer_CFFIPointer_Impl_
+#define INCLUDED_lime_system__CFFIPointer_CFFIPointer_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(lime,_hx_system,_CFFIPointer,CFFIPointer_Impl_)
+
+namespace lime{
+namespace _hx_system{
+namespace _CFFIPointer{
+
+
+class HXCPP_CLASS_ATTRIBUTES CFFIPointer_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef CFFIPointer_Impl__obj OBJ_;
+		CFFIPointer_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x2488cd1b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.system._CFFIPointer.CFFIPointer_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"lime.system._CFFIPointer.CFFIPointer_Impl_"); }
+
+		inline static hx::ObjectPtr< CFFIPointer_Impl__obj > __new() {
+			hx::ObjectPtr< CFFIPointer_Impl__obj > __this = new CFFIPointer_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< CFFIPointer_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			CFFIPointer_Impl__obj *__this = (CFFIPointer_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(CFFIPointer_Impl__obj), false, "lime.system._CFFIPointer.CFFIPointer_Impl_"));
+			*(void **)__this = CFFIPointer_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~CFFIPointer_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("CFFIPointer_Impl_",97,a2,f9,bd); }
+
+		static  ::Dynamic _new( ::Dynamic handle);
+		static ::Dynamic _new_dyn();
+
+		static Float get( ::Dynamic this1);
+		static ::Dynamic get_dyn();
+
+		static bool equals( ::Dynamic a,int b);
+		static ::Dynamic equals_dyn();
+
+		static bool equalsPointer( ::Dynamic a, ::Dynamic b);
+		static ::Dynamic equalsPointer_dyn();
+
+		static bool greaterThan( ::Dynamic a,int b);
+		static ::Dynamic greaterThan_dyn();
+
+		static bool greaterThanPointer( ::Dynamic a, ::Dynamic b);
+		static ::Dynamic greaterThanPointer_dyn();
+
+		static bool greaterThanOrEqual( ::Dynamic a,int b);
+		static ::Dynamic greaterThanOrEqual_dyn();
+
+		static bool greaterThanOrEqualPointer( ::Dynamic a, ::Dynamic b);
+		static ::Dynamic greaterThanOrEqualPointer_dyn();
+
+		static bool lessThan( ::Dynamic a,int b);
+		static ::Dynamic lessThan_dyn();
+
+		static bool lessThanPointer( ::Dynamic a, ::Dynamic b);
+		static ::Dynamic lessThanPointer_dyn();
+
+		static bool lessThanOrEqual( ::Dynamic a,int b);
+		static ::Dynamic lessThanOrEqual_dyn();
+
+		static bool lessThanOrEqualPointer( ::Dynamic a, ::Dynamic b);
+		static ::Dynamic lessThanOrEqualPointer_dyn();
+
+		static bool notEquals( ::Dynamic a,int b);
+		static ::Dynamic notEquals_dyn();
+
+		static bool notEqualsPointer( ::Dynamic a, ::Dynamic b);
+		static ::Dynamic notEqualsPointer_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace system
+} // end namespace _CFFIPointer
+
+#endif /* INCLUDED_lime_system__CFFIPointer_CFFIPointer_Impl_ */ 

hGameTest/bin/linux/obj/include/lime/system/_ThreadPool/ThreadPoolMessage.h

@@ -0,0 +1,57 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system__ThreadPool_ThreadPoolMessage
+#define INCLUDED_lime_system__ThreadPool_ThreadPoolMessage
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(lime,_hx_system,_ThreadPool,ThreadPoolMessage)
+HX_DECLARE_CLASS3(lime,_hx_system,_ThreadPool,ThreadPoolMessageType)
+
+namespace lime{
+namespace _hx_system{
+namespace _ThreadPool{
+
+
+class HXCPP_CLASS_ATTRIBUTES ThreadPoolMessage_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef ThreadPoolMessage_obj OBJ_;
+		ThreadPoolMessage_obj();
+
+	public:
+		enum { _hx_ClassId = 0x23d7cac4 };
+
+		void __construct( ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType type, ::Dynamic state);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.system._ThreadPool.ThreadPoolMessage")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"lime.system._ThreadPool.ThreadPoolMessage"); }
+		static hx::ObjectPtr< ThreadPoolMessage_obj > __new( ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType type, ::Dynamic state);
+		static hx::ObjectPtr< ThreadPoolMessage_obj > __alloc(hx::Ctx *_hx_ctx, ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType type, ::Dynamic state);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ThreadPoolMessage_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ThreadPoolMessage",81,8d,d9,cb); }
+
+		 ::Dynamic state;
+		 ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType type;
+};
+
+} // end namespace lime
+} // end namespace system
+} // end namespace _ThreadPool
+
+#endif /* INCLUDED_lime_system__ThreadPool_ThreadPoolMessage */ 

hGameTest/bin/linux/obj/include/lime/system/_ThreadPool/ThreadPoolMessageType.h

@@ -0,0 +1,45 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_system__ThreadPool_ThreadPoolMessageType
+#define INCLUDED_lime_system__ThreadPool_ThreadPoolMessageType
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(lime,_hx_system,_ThreadPool,ThreadPoolMessageType)
+namespace lime{
+namespace _hx_system{
+namespace _ThreadPool{
+
+
+class ThreadPoolMessageType_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef ThreadPoolMessageType_obj OBJ_;
+
+	public:
+		ThreadPoolMessageType_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("lime.system._ThreadPool.ThreadPoolMessageType",ec,6c,62,b0); }
+		::String __ToString() const { return HX_("ThreadPoolMessageType.",f3,be,69,35) + _hx_tag; }
+
+		static ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType COMPLETE;
+		static inline ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType COMPLETE_dyn() { return COMPLETE; }
+		static ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType ERROR;
+		static inline ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType ERROR_dyn() { return ERROR; }
+		static ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType EXIT;
+		static inline ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType EXIT_dyn() { return EXIT; }
+		static ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType PROGRESS;
+		static inline ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType PROGRESS_dyn() { return PROGRESS; }
+		static ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType WORK;
+		static inline ::lime::_hx_system::_ThreadPool::ThreadPoolMessageType WORK_dyn() { return WORK; }
+};
+
+} // end namespace lime
+} // end namespace system
+} // end namespace _ThreadPool
+
+#endif /* INCLUDED_lime_system__ThreadPool_ThreadPoolMessageType */