First commit

hGameTest/bin/linux/obj/include/lime/app/Application.h

@@ -0,0 +1,275 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Application
+#define INCLUDED_lime_app_Application
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_lime_app_Module
+#include <lime/app/Module.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,IntMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS4(lime,_internal,backend,native,NativeApplication)
+HX_DECLARE_CLASS2(lime,app,Application)
+HX_DECLARE_CLASS2(lime,app,IModule)
+HX_DECLARE_CLASS2(lime,app,Module)
+HX_DECLARE_CLASS2(lime,app,_Event_Int_Void)
+HX_DECLARE_CLASS2(lime,app,_Event_lime_ui_Window_Void)
+HX_DECLARE_CLASS2(lime,graphics,RenderContext)
+HX_DECLARE_CLASS2(lime,ui,Gamepad)
+HX_DECLARE_CLASS2(lime,ui,Joystick)
+HX_DECLARE_CLASS2(lime,ui,MouseWheelMode)
+HX_DECLARE_CLASS2(lime,ui,Touch)
+HX_DECLARE_CLASS2(lime,ui,Window)
+HX_DECLARE_CLASS2(lime,utils,Preloader)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Application_obj : public  ::lime::app::Module_obj
+{
+	public:
+		typedef  ::lime::app::Module_obj super;
+		typedef Application_obj OBJ_;
+		Application_obj();
+
+	public:
+		enum { _hx_ClassId = 0x31cfae44 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Application")
+			{ 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.app.Application"); }
+		static hx::ObjectPtr< Application_obj > __new();
+		static hx::ObjectPtr< Application_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Application_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);
+		static void __init__();
+
+		::String __ToString() const { return HX_("Application",30,43,71,0e); }
+
+		static void __boot();
+		static  ::lime::app::Application current;
+		 ::haxe::ds::StringMap meta;
+		::Array< ::Dynamic> modules;
+		 ::lime::app::_Event_Int_Void onUpdate;
+		 ::lime::app::_Event_lime_ui_Window_Void onCreateWindow;
+		 ::lime::utils::Preloader preloader;
+		 ::lime::ui::Window window;
+		::Array< ::Dynamic> windows;
+		 ::lime::_internal::backend::native::NativeApplication _hx___backend;
+		 ::lime::utils::Preloader _hx___preloader;
+		 ::lime::ui::Window _hx___window;
+		 ::haxe::ds::IntMap _hx___windowByID;
+		::Array< ::Dynamic> _hx___windows;
+		void addModule(::Dynamic module);
+		::Dynamic addModule_dyn();
+
+		virtual  ::lime::ui::Window createWindow( ::Dynamic attributes);
+		::Dynamic createWindow_dyn();
+
+		int exec();
+		::Dynamic exec_dyn();
+
+		void onGamepadAxisMove( ::lime::ui::Gamepad gamepad,int axis,Float value);
+		::Dynamic onGamepadAxisMove_dyn();
+
+		void onGamepadButtonDown( ::lime::ui::Gamepad gamepad,int button);
+		::Dynamic onGamepadButtonDown_dyn();
+
+		void onGamepadButtonUp( ::lime::ui::Gamepad gamepad,int button);
+		::Dynamic onGamepadButtonUp_dyn();
+
+		void onGamepadConnect( ::lime::ui::Gamepad gamepad);
+		::Dynamic onGamepadConnect_dyn();
+
+		void onGamepadDisconnect( ::lime::ui::Gamepad gamepad);
+		::Dynamic onGamepadDisconnect_dyn();
+
+		void onJoystickAxisMove( ::lime::ui::Joystick joystick,int axis,Float value);
+		::Dynamic onJoystickAxisMove_dyn();
+
+		void onJoystickButtonDown( ::lime::ui::Joystick joystick,int button);
+		::Dynamic onJoystickButtonDown_dyn();
+
+		void onJoystickButtonUp( ::lime::ui::Joystick joystick,int button);
+		::Dynamic onJoystickButtonUp_dyn();
+
+		void onJoystickConnect( ::lime::ui::Joystick joystick);
+		::Dynamic onJoystickConnect_dyn();
+
+		void onJoystickDisconnect( ::lime::ui::Joystick joystick);
+		::Dynamic onJoystickDisconnect_dyn();
+
+		void onJoystickHatMove( ::lime::ui::Joystick joystick,int hat,int position);
+		::Dynamic onJoystickHatMove_dyn();
+
+		void onJoystickTrackballMove( ::lime::ui::Joystick joystick,int trackball,Float x,Float y);
+		::Dynamic onJoystickTrackballMove_dyn();
+
+		void onKeyDown(int keyCode,int modifier);
+		::Dynamic onKeyDown_dyn();
+
+		void onKeyUp(int keyCode,int modifier);
+		::Dynamic onKeyUp_dyn();
+
+		void onModuleExit(int code);
+		::Dynamic onModuleExit_dyn();
+
+		void onMouseDown(Float x,Float y,int button);
+		::Dynamic onMouseDown_dyn();
+
+		void onMouseMove(Float x,Float y);
+		::Dynamic onMouseMove_dyn();
+
+		void onMouseMoveRelative(Float x,Float y);
+		::Dynamic onMouseMoveRelative_dyn();
+
+		void onMouseUp(Float x,Float y,int button);
+		::Dynamic onMouseUp_dyn();
+
+		void onMouseWheel(Float deltaX,Float deltaY, ::lime::ui::MouseWheelMode deltaMode);
+		::Dynamic onMouseWheel_dyn();
+
+		void onPreloadComplete();
+		::Dynamic onPreloadComplete_dyn();
+
+		void onPreloadProgress(int loaded,int total);
+		::Dynamic onPreloadProgress_dyn();
+
+		void onRenderContextLost();
+		::Dynamic onRenderContextLost_dyn();
+
+		void onRenderContextRestored( ::lime::graphics::RenderContext context);
+		::Dynamic onRenderContextRestored_dyn();
+
+		void onTextEdit(::String text,int start,int length);
+		::Dynamic onTextEdit_dyn();
+
+		void onTextInput(::String text);
+		::Dynamic onTextInput_dyn();
+
+		void onTouchCancel( ::lime::ui::Touch touch);
+		::Dynamic onTouchCancel_dyn();
+
+		void onTouchEnd( ::lime::ui::Touch touch);
+		::Dynamic onTouchEnd_dyn();
+
+		void onTouchMove( ::lime::ui::Touch touch);
+		::Dynamic onTouchMove_dyn();
+
+		void onTouchStart( ::lime::ui::Touch touch);
+		::Dynamic onTouchStart_dyn();
+
+		void onWindowActivate();
+		::Dynamic onWindowActivate_dyn();
+
+		void onWindowClose();
+		::Dynamic onWindowClose_dyn();
+
+		void onWindowCreate();
+		::Dynamic onWindowCreate_dyn();
+
+		void onWindowDeactivate();
+		::Dynamic onWindowDeactivate_dyn();
+
+		void onWindowDropFile(::String file);
+		::Dynamic onWindowDropFile_dyn();
+
+		void onWindowEnter();
+		::Dynamic onWindowEnter_dyn();
+
+		void onWindowExpose();
+		::Dynamic onWindowExpose_dyn();
+
+		void onWindowFocusIn();
+		::Dynamic onWindowFocusIn_dyn();
+
+		void onWindowFocusOut();
+		::Dynamic onWindowFocusOut_dyn();
+
+		void onWindowFullscreen();
+		::Dynamic onWindowFullscreen_dyn();
+
+		void onWindowLeave();
+		::Dynamic onWindowLeave_dyn();
+
+		void onWindowMove(Float x,Float y);
+		::Dynamic onWindowMove_dyn();
+
+		void onWindowMinimize();
+		::Dynamic onWindowMinimize_dyn();
+
+		void onWindowResize(int width,int height);
+		::Dynamic onWindowResize_dyn();
+
+		void onWindowRestore();
+		::Dynamic onWindowRestore_dyn();
+
+		void removeModule(::Dynamic module);
+		::Dynamic removeModule_dyn();
+
+		void render( ::lime::graphics::RenderContext context);
+		::Dynamic render_dyn();
+
+		void update(int deltaTime);
+		::Dynamic update_dyn();
+
+		void _hx___addWindow( ::lime::ui::Window window);
+		::Dynamic _hx___addWindow_dyn();
+
+		 ::lime::ui::Window _hx___createWindow( ::Dynamic attributes);
+		::Dynamic _hx___createWindow_dyn();
+
+		void _hx___registerLimeModule( ::lime::app::Application application);
+
+		void _hx___removeWindow( ::lime::ui::Window window);
+		::Dynamic _hx___removeWindow_dyn();
+
+		void _hx___onGamepadConnect( ::lime::ui::Gamepad gamepad);
+		::Dynamic _hx___onGamepadConnect_dyn();
+
+		void _hx___onJoystickConnect( ::lime::ui::Joystick joystick);
+		::Dynamic _hx___onJoystickConnect_dyn();
+
+		void _hx___onModuleExit(int code);
+		::Dynamic _hx___onModuleExit_dyn();
+
+		void _hx___onWindowClose( ::lime::ui::Window window);
+		::Dynamic _hx___onWindowClose_dyn();
+
+		void _hx___unregisterLimeModule( ::lime::app::Application application);
+
+		 ::lime::utils::Preloader get_preloader();
+		::Dynamic get_preloader_dyn();
+
+		 ::lime::ui::Window get_window();
+		::Dynamic get_window_dyn();
+
+		::Array< ::Dynamic> get_windows();
+		::Dynamic get_windows_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Application */ 

hGameTest/bin/linux/obj/include/lime/app/Event.h

@@ -0,0 +1,69 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Event
+#define INCLUDED_lime_app_Event
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,Event)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Event_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Event_obj OBJ_;
+		Event_obj();
+
+	public:
+		enum { _hx_ClassId = 0x75705c0e };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Event")
+			{ 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.app.Event"); }
+		static hx::ObjectPtr< Event_obj > __new();
+		static hx::ObjectPtr< Event_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Event_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_("Event",fa,37,f2,08); }
+
+		bool canceled;
+		::cpp::VirtualArray _hx___listeners;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		 ::Dynamic dispatch;
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Event */ 

hGameTest/bin/linux/obj/include/lime/app/Future.h

@@ -0,0 +1,90 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Future
+#define INCLUDED_lime_app_Future
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,_Event_Dynamic_Void)
+HX_DECLARE_CLASS2(lime,app,_Event_Int_Int_Void)
+HX_DECLARE_CLASS2(lime,app,_Event_ofEvents_T_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Future_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Future_obj OBJ_;
+		Future_obj();
+
+	public:
+		enum { _hx_ClassId = 0x29c479cf };
+
+		void __construct( ::Dynamic work,hx::Null< bool >  __o_async);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Future")
+			{ 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.app.Future"); }
+		static hx::ObjectPtr< Future_obj > __new( ::Dynamic work,hx::Null< bool >  __o_async);
+		static hx::ObjectPtr< Future_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic work,hx::Null< bool >  __o_async);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Future_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);
+		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_("Future",63,0c,e3,a7); }
+
+		static  ::lime::app::Future ofEvents( ::lime::app::_Event_ofEvents_T_Void onComplete, ::lime::app::_Event_Dynamic_Void onError, ::lime::app::_Event_Int_Int_Void onProgress);
+		static ::Dynamic ofEvents_dyn();
+
+		static  ::lime::app::Future withError( ::Dynamic error);
+		static ::Dynamic withError_dyn();
+
+		static  ::lime::app::Future withValue( ::Dynamic value);
+		static ::Dynamic withValue_dyn();
+
+		 ::Dynamic error;
+		bool isComplete;
+		bool isError;
+		 ::Dynamic value;
+		::Array< ::Dynamic> _hx___completeListeners;
+		::Array< ::Dynamic> _hx___errorListeners;
+		::Array< ::Dynamic> _hx___progressListeners;
+		 ::lime::app::Future onComplete( ::Dynamic listener);
+		::Dynamic onComplete_dyn();
+
+		 ::lime::app::Future onError( ::Dynamic listener);
+		::Dynamic onError_dyn();
+
+		 ::lime::app::Future onProgress( ::Dynamic listener);
+		::Dynamic onProgress_dyn();
+
+		 ::lime::app::Future ready(hx::Null< int >  waitTime);
+		::Dynamic ready_dyn();
+
+		 ::Dynamic result(hx::Null< int >  waitTime);
+		::Dynamic result_dyn();
+
+		 ::lime::app::Future then( ::Dynamic next);
+		::Dynamic then_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Future */ 

hGameTest/bin/linux/obj/include/lime/app/IModule.h

@@ -0,0 +1,35 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_IModule
+#define INCLUDED_lime_app_IModule
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,Application)
+HX_DECLARE_CLASS2(lime,app,IModule)
+HX_DECLARE_CLASS2(lime,app,Module)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES IModule_obj {
+	public:
+		typedef hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		void (hx::Object :: *_hx__hx___registerLimeModule)( ::lime::app::Application application); 
+		static inline void _hx___registerLimeModule( ::Dynamic _hx_, ::lime::app::Application application) {
+			(_hx_.mPtr->*( hx::interface_cast< ::lime::app::IModule_obj *>(_hx_.mPtr->_hx_getInterface(0xf464d6e9)))->_hx__hx___registerLimeModule)(application);
+		}
+		void (hx::Object :: *_hx__hx___unregisterLimeModule)( ::lime::app::Application application); 
+		static inline void _hx___unregisterLimeModule( ::Dynamic _hx_, ::lime::app::Application application) {
+			(_hx_.mPtr->*( hx::interface_cast< ::lime::app::IModule_obj *>(_hx_.mPtr->_hx_getInterface(0xf464d6e9)))->_hx__hx___unregisterLimeModule)(application);
+		}
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_IModule */ 

hGameTest/bin/linux/obj/include/lime/app/Module.h

@@ -0,0 +1,66 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Module
+#define INCLUDED_lime_app_Module
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_lime_app_IModule
+#include <lime/app/IModule.h>
+#endif
+HX_DECLARE_CLASS2(lime,app,Application)
+HX_DECLARE_CLASS2(lime,app,IModule)
+HX_DECLARE_CLASS2(lime,app,Module)
+HX_DECLARE_CLASS2(lime,app,_Event_Int_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Module_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Module_obj OBJ_;
+		Module_obj();
+
+	public:
+		enum { _hx_ClassId = 0x77491638 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Module")
+			{ 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.app.Module"); }
+		static hx::ObjectPtr< Module_obj > __new();
+		static hx::ObjectPtr< Module_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Module_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);
+		void *_hx_getInterface(int inHash);
+		::String __ToString() const { return HX_("Module",cc,a8,67,f5); }
+
+		 ::lime::app::_Event_Int_Void onExit;
+		virtual void _hx___registerLimeModule( ::lime::app::Application application);
+		::Dynamic _hx___registerLimeModule_dyn();
+
+		virtual void _hx___unregisterLimeModule( ::lime::app::Application application);
+		::Dynamic _hx___unregisterLimeModule_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Module */ 

hGameTest/bin/linux/obj/include/lime/app/Promise.h

@@ -0,0 +1,74 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Promise
+#define INCLUDED_lime_app_Promise
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,Promise)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Promise_obj OBJ_;
+		Promise_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7a57dccf };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Promise")
+			{ 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.app.Promise"); }
+		static hx::ObjectPtr< Promise_obj > __new();
+		static hx::ObjectPtr< Promise_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Promise_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_("Promise",7b,f5,3a,c5); }
+
+		 ::lime::app::Future future;
+		bool isComplete;
+		bool isError;
+		 ::lime::app::Promise complete( ::Dynamic data);
+		::Dynamic complete_dyn();
+
+		 ::lime::app::Promise completeWith( ::lime::app::Future future);
+		::Dynamic completeWith_dyn();
+
+		 ::lime::app::Promise error( ::Dynamic msg);
+		::Dynamic error_dyn();
+
+		 ::lime::app::Promise progress(int progress,int total);
+		::Dynamic progress_dyn();
+
+		bool get_isComplete();
+		::Dynamic get_isComplete_dyn();
+
+		bool get_isError();
+		::Dynamic get_isError_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Promise */ 

hGameTest/bin/linux/obj/include/lime/app/Promise_String.h

@@ -0,0 +1,74 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Promise_String
+#define INCLUDED_lime_app_Promise_String
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,Promise_String)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_String_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Promise_String_obj OBJ_;
+		Promise_String_obj();
+
+	public:
+		enum { _hx_ClassId = 0x30fcb2fd };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Promise_String")
+			{ 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.app.Promise_String"); }
+		static hx::ObjectPtr< Promise_String_obj > __new();
+		static hx::ObjectPtr< Promise_String_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Promise_String_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_("Promise_String",75,2e,b6,2c); }
+
+		 ::lime::app::Future future;
+		bool isComplete;
+		bool isError;
+		 ::lime::app::Promise_String complete(::String data);
+		::Dynamic complete_dyn();
+
+		 ::lime::app::Promise_String completeWith( ::lime::app::Future future);
+		::Dynamic completeWith_dyn();
+
+		 ::lime::app::Promise_String error( ::Dynamic msg);
+		::Dynamic error_dyn();
+
+		 ::lime::app::Promise_String progress(int progress,int total);
+		::Dynamic progress_dyn();
+
+		bool get_isComplete();
+		::Dynamic get_isComplete_dyn();
+
+		bool get_isError();
+		::Dynamic get_isError_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Promise_String */ 

hGameTest/bin/linux/obj/include/lime/app/Promise_haxe_io_Bytes.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Promise_haxe_io_Bytes
+#define INCLUDED_lime_app_Promise_haxe_io_Bytes
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,Promise_haxe_io_Bytes)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_haxe_io_Bytes_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Promise_haxe_io_Bytes_obj OBJ_;
+		Promise_haxe_io_Bytes_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3e090d7b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Promise_haxe_io_Bytes")
+			{ 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.app.Promise_haxe_io_Bytes"); }
+		static hx::ObjectPtr< Promise_haxe_io_Bytes_obj > __new();
+		static hx::ObjectPtr< Promise_haxe_io_Bytes_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Promise_haxe_io_Bytes_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_("Promise_haxe_io_Bytes",67,81,f6,f0); }
+
+		 ::lime::app::Future future;
+		bool isComplete;
+		bool isError;
+		 ::lime::app::Promise_haxe_io_Bytes complete( ::haxe::io::Bytes data);
+		::Dynamic complete_dyn();
+
+		 ::lime::app::Promise_haxe_io_Bytes completeWith( ::lime::app::Future future);
+		::Dynamic completeWith_dyn();
+
+		 ::lime::app::Promise_haxe_io_Bytes error( ::Dynamic msg);
+		::Dynamic error_dyn();
+
+		 ::lime::app::Promise_haxe_io_Bytes progress(int progress,int total);
+		::Dynamic progress_dyn();
+
+		bool get_isComplete();
+		::Dynamic get_isComplete_dyn();
+
+		bool get_isError();
+		::Dynamic get_isError_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Promise_haxe_io_Bytes */ 

hGameTest/bin/linux/obj/include/lime/app/Promise_lime_media_AudioBuffer.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Promise_lime_media_AudioBuffer
+#define INCLUDED_lime_app_Promise_lime_media_AudioBuffer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,Promise_lime_media_AudioBuffer)
+HX_DECLARE_CLASS2(lime,media,AudioBuffer)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_lime_media_AudioBuffer_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Promise_lime_media_AudioBuffer_obj OBJ_;
+		Promise_lime_media_AudioBuffer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x47c2125d };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Promise_lime_media_AudioBuffer")
+			{ 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.app.Promise_lime_media_AudioBuffer"); }
+		static hx::ObjectPtr< Promise_lime_media_AudioBuffer_obj > __new();
+		static hx::ObjectPtr< Promise_lime_media_AudioBuffer_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Promise_lime_media_AudioBuffer_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_("Promise_lime_media_AudioBuffer",d5,fd,ab,8d); }
+
+		 ::lime::app::Future future;
+		bool isComplete;
+		bool isError;
+		 ::lime::app::Promise_lime_media_AudioBuffer complete( ::lime::media::AudioBuffer data);
+		::Dynamic complete_dyn();
+
+		 ::lime::app::Promise_lime_media_AudioBuffer completeWith( ::lime::app::Future future);
+		::Dynamic completeWith_dyn();
+
+		 ::lime::app::Promise_lime_media_AudioBuffer error( ::Dynamic msg);
+		::Dynamic error_dyn();
+
+		 ::lime::app::Promise_lime_media_AudioBuffer progress(int progress,int total);
+		::Dynamic progress_dyn();
+
+		bool get_isComplete();
+		::Dynamic get_isComplete_dyn();
+
+		bool get_isError();
+		::Dynamic get_isError_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Promise_lime_media_AudioBuffer */ 

hGameTest/bin/linux/obj/include/lime/app/Promise_lime_text_Font.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Promise_lime_text_Font
+#define INCLUDED_lime_app_Promise_lime_text_Font
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,Promise_lime_text_Font)
+HX_DECLARE_CLASS2(lime,text,Font)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_lime_text_Font_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Promise_lime_text_Font_obj OBJ_;
+		Promise_lime_text_Font_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3a6ea007 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Promise_lime_text_Font")
+			{ 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.app.Promise_lime_text_Font"); }
+		static hx::ObjectPtr< Promise_lime_text_Font_obj > __new();
+		static hx::ObjectPtr< Promise_lime_text_Font_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Promise_lime_text_Font_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_("Promise_lime_text_Font",9b,9a,46,17); }
+
+		 ::lime::app::Future future;
+		bool isComplete;
+		bool isError;
+		 ::lime::app::Promise_lime_text_Font complete( ::lime::text::Font data);
+		::Dynamic complete_dyn();
+
+		 ::lime::app::Promise_lime_text_Font completeWith( ::lime::app::Future future);
+		::Dynamic completeWith_dyn();
+
+		 ::lime::app::Promise_lime_text_Font error( ::Dynamic msg);
+		::Dynamic error_dyn();
+
+		 ::lime::app::Promise_lime_text_Font progress(int progress,int total);
+		::Dynamic progress_dyn();
+
+		bool get_isComplete();
+		::Dynamic get_isComplete_dyn();
+
+		bool get_isError();
+		::Dynamic get_isError_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Promise_lime_text_Font */ 

hGameTest/bin/linux/obj/include/lime/app/Promise_lime_utils_AssetLibrary.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Promise_lime_utils_AssetLibrary
+#define INCLUDED_lime_app_Promise_lime_utils_AssetLibrary
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,Promise_lime_utils_AssetLibrary)
+HX_DECLARE_CLASS2(lime,utils,AssetLibrary)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_lime_utils_AssetLibrary_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Promise_lime_utils_AssetLibrary_obj OBJ_;
+		Promise_lime_utils_AssetLibrary_obj();
+
+	public:
+		enum { _hx_ClassId = 0x699ea253 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Promise_lime_utils_AssetLibrary")
+			{ 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.app.Promise_lime_utils_AssetLibrary"); }
+		static hx::ObjectPtr< Promise_lime_utils_AssetLibrary_obj > __new();
+		static hx::ObjectPtr< Promise_lime_utils_AssetLibrary_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Promise_lime_utils_AssetLibrary_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_("Promise_lime_utils_AssetLibrary",3f,b5,04,9e); }
+
+		 ::lime::app::Future future;
+		bool isComplete;
+		bool isError;
+		 ::lime::app::Promise_lime_utils_AssetLibrary complete( ::lime::utils::AssetLibrary data);
+		::Dynamic complete_dyn();
+
+		 ::lime::app::Promise_lime_utils_AssetLibrary completeWith( ::lime::app::Future future);
+		::Dynamic completeWith_dyn();
+
+		 ::lime::app::Promise_lime_utils_AssetLibrary error( ::Dynamic msg);
+		::Dynamic error_dyn();
+
+		 ::lime::app::Promise_lime_utils_AssetLibrary progress(int progress,int total);
+		::Dynamic progress_dyn();
+
+		bool get_isComplete();
+		::Dynamic get_isComplete_dyn();
+
+		bool get_isError();
+		::Dynamic get_isError_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Promise_lime_utils_AssetLibrary */ 

hGameTest/bin/linux/obj/include/lime/app/Promise_openfl_display_BitmapData.h

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Promise_openfl_display_BitmapData
+#define INCLUDED_lime_app_Promise_openfl_display_BitmapData
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,Promise_openfl_display_BitmapData)
+HX_DECLARE_CLASS2(openfl,display,BitmapData)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_openfl_display_BitmapData_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Promise_openfl_display_BitmapData_obj OBJ_;
+		Promise_openfl_display_BitmapData_obj();
+
+	public:
+		enum { _hx_ClassId = 0x34e4c595 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Promise_openfl_display_BitmapData")
+			{ 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.app.Promise_openfl_display_BitmapData"); }
+		static hx::ObjectPtr< Promise_openfl_display_BitmapData_obj > __new();
+		static hx::ObjectPtr< Promise_openfl_display_BitmapData_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Promise_openfl_display_BitmapData_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_("Promise_openfl_display_BitmapData",81,6b,26,dd); }
+
+		 ::lime::app::Future future;
+		bool isComplete;
+		bool isError;
+		 ::lime::app::Promise_openfl_display_BitmapData complete( ::openfl::display::BitmapData data);
+		::Dynamic complete_dyn();
+
+		 ::lime::app::Promise_openfl_display_BitmapData completeWith( ::lime::app::Future future);
+		::Dynamic completeWith_dyn();
+
+		 ::lime::app::Promise_openfl_display_BitmapData error( ::Dynamic msg);
+		::Dynamic error_dyn();
+
+		 ::lime::app::Promise_openfl_display_BitmapData progress(int progress,int total);
+		::Dynamic progress_dyn();
+
+		bool get_isComplete();
+		::Dynamic get_isComplete_dyn();
+
+		bool get_isError();
+		::Dynamic get_isError_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Promise_openfl_display_BitmapData */ 

hGameTest/bin/linux/obj/include/lime/app/Promise_openfl_display_MovieClip.h

@@ -0,0 +1,82 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Promise_openfl_display_MovieClip
+#define INCLUDED_lime_app_Promise_openfl_display_MovieClip
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,Promise_openfl_display_MovieClip)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectContainer)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,display,MovieClip)
+HX_DECLARE_CLASS2(openfl,display,Sprite)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_openfl_display_MovieClip_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Promise_openfl_display_MovieClip_obj OBJ_;
+		Promise_openfl_display_MovieClip_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2dcc267c };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Promise_openfl_display_MovieClip")
+			{ 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.app.Promise_openfl_display_MovieClip"); }
+		static hx::ObjectPtr< Promise_openfl_display_MovieClip_obj > __new();
+		static hx::ObjectPtr< Promise_openfl_display_MovieClip_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Promise_openfl_display_MovieClip_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_("Promise_openfl_display_MovieClip",d8,1d,8d,92); }
+
+		 ::lime::app::Future future;
+		bool isComplete;
+		bool isError;
+		 ::lime::app::Promise_openfl_display_MovieClip complete( ::openfl::display::MovieClip data);
+		::Dynamic complete_dyn();
+
+		 ::lime::app::Promise_openfl_display_MovieClip completeWith( ::lime::app::Future future);
+		::Dynamic completeWith_dyn();
+
+		 ::lime::app::Promise_openfl_display_MovieClip error( ::Dynamic msg);
+		::Dynamic error_dyn();
+
+		 ::lime::app::Promise_openfl_display_MovieClip progress(int progress,int total);
+		::Dynamic progress_dyn();
+
+		bool get_isComplete();
+		::Dynamic get_isComplete_dyn();
+
+		bool get_isError();
+		::Dynamic get_isError_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Promise_openfl_display_MovieClip */ 

hGameTest/bin/linux/obj/include/lime/app/Promise_openfl_media_Sound.h

@@ -0,0 +1,77 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Promise_openfl_media_Sound
+#define INCLUDED_lime_app_Promise_openfl_media_Sound
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,Promise_openfl_media_Sound)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,media,Sound)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_openfl_media_Sound_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Promise_openfl_media_Sound_obj OBJ_;
+		Promise_openfl_media_Sound_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5b0a2d71 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Promise_openfl_media_Sound")
+			{ 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.app.Promise_openfl_media_Sound"); }
+		static hx::ObjectPtr< Promise_openfl_media_Sound_obj > __new();
+		static hx::ObjectPtr< Promise_openfl_media_Sound_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Promise_openfl_media_Sound_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_("Promise_openfl_media_Sound",e9,fc,ca,b6); }
+
+		 ::lime::app::Future future;
+		bool isComplete;
+		bool isError;
+		 ::lime::app::Promise_openfl_media_Sound complete( ::openfl::media::Sound data);
+		::Dynamic complete_dyn();
+
+		 ::lime::app::Promise_openfl_media_Sound completeWith( ::lime::app::Future future);
+		::Dynamic completeWith_dyn();
+
+		 ::lime::app::Promise_openfl_media_Sound error( ::Dynamic msg);
+		::Dynamic error_dyn();
+
+		 ::lime::app::Promise_openfl_media_Sound progress(int progress,int total);
+		::Dynamic progress_dyn();
+
+		bool get_isComplete();
+		::Dynamic get_isComplete_dyn();
+
+		bool get_isError();
+		::Dynamic get_isError_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Promise_openfl_media_Sound */ 

hGameTest/bin/linux/obj/include/lime/app/Promise_openfl_text_Font.h

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Promise_openfl_text_Font
+#define INCLUDED_lime_app_Promise_openfl_text_Font
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,Promise_openfl_text_Font)
+HX_DECLARE_CLASS2(lime,text,Font)
+HX_DECLARE_CLASS2(openfl,text,Font)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_openfl_text_Font_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Promise_openfl_text_Font_obj OBJ_;
+		Promise_openfl_text_Font_obj();
+
+	public:
+		enum { _hx_ClassId = 0x331d1042 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Promise_openfl_text_Font")
+			{ 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.app.Promise_openfl_text_Font"); }
+		static hx::ObjectPtr< Promise_openfl_text_Font_obj > __new();
+		static hx::ObjectPtr< Promise_openfl_text_Font_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Promise_openfl_text_Font_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_("Promise_openfl_text_Font",d6,d7,d7,f1); }
+
+		 ::lime::app::Future future;
+		bool isComplete;
+		bool isError;
+		 ::lime::app::Promise_openfl_text_Font complete( ::openfl::text::Font data);
+		::Dynamic complete_dyn();
+
+		 ::lime::app::Promise_openfl_text_Font completeWith( ::lime::app::Future future);
+		::Dynamic completeWith_dyn();
+
+		 ::lime::app::Promise_openfl_text_Font error( ::Dynamic msg);
+		::Dynamic error_dyn();
+
+		 ::lime::app::Promise_openfl_text_Font progress(int progress,int total);
+		::Dynamic progress_dyn();
+
+		bool get_isComplete();
+		::Dynamic get_isComplete_dyn();
+
+		bool get_isError();
+		::Dynamic get_isError_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Promise_openfl_text_Font */ 

hGameTest/bin/linux/obj/include/lime/app/Promise_openfl_utils_ByteArray.h

@@ -0,0 +1,78 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app_Promise_openfl_utils_ByteArray
+#define INCLUDED_lime_app_Promise_openfl_utils_ByteArray
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(lime,app,Future)
+HX_DECLARE_CLASS2(lime,app,Promise_openfl_utils_ByteArray)
+HX_DECLARE_CLASS2(openfl,utils,ByteArrayData)
+HX_DECLARE_CLASS2(openfl,utils,IDataInput)
+HX_DECLARE_CLASS2(openfl,utils,IDataOutput)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES Promise_openfl_utils_ByteArray_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Promise_openfl_utils_ByteArray_obj OBJ_;
+		Promise_openfl_utils_ByteArray_obj();
+
+	public:
+		enum { _hx_ClassId = 0x23dc3f84 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app.Promise_openfl_utils_ByteArray")
+			{ 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.app.Promise_openfl_utils_ByteArray"); }
+		static hx::ObjectPtr< Promise_openfl_utils_ByteArray_obj > __new();
+		static hx::ObjectPtr< Promise_openfl_utils_ByteArray_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Promise_openfl_utils_ByteArray_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_("Promise_openfl_utils_ByteArray",18,ee,ce,e3); }
+
+		 ::lime::app::Future future;
+		bool isComplete;
+		bool isError;
+		 ::lime::app::Promise_openfl_utils_ByteArray complete( ::openfl::utils::ByteArrayData data);
+		::Dynamic complete_dyn();
+
+		 ::lime::app::Promise_openfl_utils_ByteArray completeWith( ::lime::app::Future future);
+		::Dynamic completeWith_dyn();
+
+		 ::lime::app::Promise_openfl_utils_ByteArray error( ::Dynamic msg);
+		::Dynamic error_dyn();
+
+		 ::lime::app::Promise_openfl_utils_ByteArray progress(int progress,int total);
+		::Dynamic progress_dyn();
+
+		bool get_isComplete();
+		::Dynamic get_isComplete_dyn();
+
+		bool get_isError();
+		::Dynamic get_isError_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app_Promise_openfl_utils_ByteArray */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_Dynamic_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_Dynamic_Void
+#define INCLUDED_lime_app__Event_Dynamic_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Dynamic_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_Dynamic_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_Dynamic_Void_obj OBJ_;
+		_Event_Dynamic_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1d3b9434 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_Dynamic_Void")
+			{ 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.app._Event_Dynamic_Void"); }
+		static hx::ObjectPtr< _Event_Dynamic_Void_obj > __new();
+		static hx::ObjectPtr< _Event_Dynamic_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_Dynamic_Void_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_("_Event_Dynamic_Void",58,16,11,bc); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch( ::Dynamic a);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_Dynamic_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_Float_Float_Float_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_Float_Float_Float_Void
+#define INCLUDED_lime_app__Event_Float_Float_Float_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Float_Float_Float_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_Float_Float_Float_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_Float_Float_Float_Void_obj OBJ_;
+		_Event_Float_Float_Float_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x30cf5ab5 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_Float_Float_Float_Void")
+			{ 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.app._Event_Float_Float_Float_Void"); }
+		static hx::ObjectPtr< _Event_Float_Float_Float_Void_obj > __new();
+		static hx::ObjectPtr< _Event_Float_Float_Float_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_Float_Float_Float_Void_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_("_Event_Float_Float_Float_Void",a1,9a,74,01); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(Float a,Float a1,Float a2);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_Float_Float_Float_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_Float_Float_Int_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_Float_Float_Int_Void
+#define INCLUDED_lime_app__Event_Float_Float_Int_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Float_Float_Int_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_Float_Float_Int_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_Float_Float_Int_Void_obj OBJ_;
+		_Event_Float_Float_Int_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x14ab6b02 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_Float_Float_Int_Void")
+			{ 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.app._Event_Float_Float_Int_Void"); }
+		static hx::ObjectPtr< _Event_Float_Float_Int_Void_obj > __new();
+		static hx::ObjectPtr< _Event_Float_Float_Int_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_Float_Float_Int_Void_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_("_Event_Float_Float_Int_Void",ee,97,7a,b1); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(Float a,Float a1,int a2);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_Float_Float_Int_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_Float_Float_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_Float_Float_Void
+#define INCLUDED_lime_app__Event_Float_Float_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Float_Float_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_Float_Float_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_Float_Float_Void_obj OBJ_;
+		_Event_Float_Float_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x33f29b52 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_Float_Float_Void")
+			{ 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.app._Event_Float_Float_Void"); }
+		static hx::ObjectPtr< _Event_Float_Float_Void_obj > __new();
+		static hx::ObjectPtr< _Event_Float_Float_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_Float_Float_Void_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_("_Event_Float_Float_Void",3e,e2,15,94); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(Float a,Float a1);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_Float_Float_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_Float_Float_lime_ui_MouseButton_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_Float_Float_lime_ui_MouseButton_Void
+#define INCLUDED_lime_app__Event_Float_Float_lime_ui_MouseButton_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Float_Float_lime_ui_MouseButton_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_Float_Float_lime_ui_MouseButton_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_Float_Float_lime_ui_MouseButton_Void_obj OBJ_;
+		_Event_Float_Float_lime_ui_MouseButton_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x165da11b };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_Float_Float_lime_ui_MouseButton_Void")
+			{ 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.app._Event_Float_Float_lime_ui_MouseButton_Void"); }
+		static hx::ObjectPtr< _Event_Float_Float_lime_ui_MouseButton_Void_obj > __new();
+		static hx::ObjectPtr< _Event_Float_Float_lime_ui_MouseButton_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_Float_Float_lime_ui_MouseButton_Void_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_("_Event_Float_Float_lime_ui_MouseButton_Void",07,66,0a,22); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(Float a,Float a1,int a2);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_Float_Float_lime_ui_MouseButton_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_Float_Float_lime_ui_MouseWheelMode_Void.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_Float_Float_lime_ui_MouseWheelMode_Void
+#define INCLUDED_lime_app__Event_Float_Float_lime_ui_MouseWheelMode_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Float_Float_lime_ui_MouseWheelMode_Void)
+HX_DECLARE_CLASS2(lime,ui,MouseWheelMode)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_Float_Float_lime_ui_MouseWheelMode_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_Float_Float_lime_ui_MouseWheelMode_Void_obj OBJ_;
+		_Event_Float_Float_lime_ui_MouseWheelMode_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0e4e0bc7 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_Float_Float_lime_ui_MouseWheelMode_Void")
+			{ 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.app._Event_Float_Float_lime_ui_MouseWheelMode_Void"); }
+		static hx::ObjectPtr< _Event_Float_Float_lime_ui_MouseWheelMode_Void_obj > __new();
+		static hx::ObjectPtr< _Event_Float_Float_lime_ui_MouseWheelMode_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_Float_Float_lime_ui_MouseWheelMode_Void_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_("_Event_Float_Float_lime_ui_MouseWheelMode_Void",cf,7a,a1,53); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(Float a,Float a1, ::lime::ui::MouseWheelMode a2);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_Float_Float_lime_ui_MouseWheelMode_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_Int_Float_Float_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_Int_Float_Float_Void
+#define INCLUDED_lime_app__Event_Int_Float_Float_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Int_Float_Float_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_Int_Float_Float_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_Int_Float_Float_Void_obj OBJ_;
+		_Event_Int_Float_Float_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x6d633802 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_Int_Float_Float_Void")
+			{ 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.app._Event_Int_Float_Float_Void"); }
+		static hx::ObjectPtr< _Event_Int_Float_Float_Void_obj > __new();
+		static hx::ObjectPtr< _Event_Int_Float_Float_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_Int_Float_Float_Void_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_("_Event_Int_Float_Float_Void",ee,64,32,0a); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(int a,Float a1,Float a2);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_Int_Float_Float_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_Int_Float_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_Int_Float_Void
+#define INCLUDED_lime_app__Event_Int_Float_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Int_Float_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_Int_Float_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_Int_Float_Void_obj OBJ_;
+		_Event_Int_Float_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x41fe50df };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_Int_Float_Void")
+			{ 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.app._Event_Int_Float_Void"); }
+		static hx::ObjectPtr< _Event_Int_Float_Void_obj > __new();
+		static hx::ObjectPtr< _Event_Int_Float_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_Int_Float_Void_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_("_Event_Int_Float_Void",cb,c4,eb,f4); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(int a,Float a1);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_Int_Float_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_Int_Int_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_Int_Int_Void
+#define INCLUDED_lime_app__Event_Int_Int_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Int_Int_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_Int_Int_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_Int_Int_Void_obj OBJ_;
+		_Event_Int_Int_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x22241210 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_Int_Int_Void")
+			{ 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.app._Event_Int_Int_Void"); }
+		static hx::ObjectPtr< _Event_Int_Int_Void_obj > __new();
+		static hx::ObjectPtr< _Event_Int_Int_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_Int_Int_Void_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_("_Event_Int_Int_Void",98,03,00,e8); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(int a,int a1);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_Int_Int_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_Int_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_Int_Void
+#define INCLUDED_lime_app__Event_Int_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Int_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_Int_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_Int_Void_obj OBJ_;
+		_Event_Int_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x01e510c4 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_Int_Void")
+			{ 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.app._Event_Int_Void"); }
+		static hx::ObjectPtr< _Event_Int_Void_obj > __new();
+		static hx::ObjectPtr< _Event_Int_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_Int_Void_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_("_Event_Int_Void",e8,b0,7d,1d); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(int a);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_Int_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_Int_lime_ui_JoystickHatPosition_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_Int_lime_ui_JoystickHatPosition_Void
+#define INCLUDED_lime_app__Event_Int_lime_ui_JoystickHatPosition_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Int_lime_ui_JoystickHatPosition_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_Int_lime_ui_JoystickHatPosition_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_Int_lime_ui_JoystickHatPosition_Void_obj OBJ_;
+		_Event_Int_lime_ui_JoystickHatPosition_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0d95f654 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_Int_lime_ui_JoystickHatPosition_Void")
+			{ 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.app._Event_Int_lime_ui_JoystickHatPosition_Void"); }
+		static hx::ObjectPtr< _Event_Int_lime_ui_JoystickHatPosition_Void_obj > __new();
+		static hx::ObjectPtr< _Event_Int_lime_ui_JoystickHatPosition_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_Int_lime_ui_JoystickHatPosition_Void_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_("_Event_Int_lime_ui_JoystickHatPosition_Void",40,bb,42,19); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(int a,int a1);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_Int_lime_ui_JoystickHatPosition_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_String_Int_Int_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_String_Int_Int_Void
+#define INCLUDED_lime_app__Event_String_Int_Int_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_String_Int_Int_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_String_Int_Int_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_String_Int_Int_Void_obj OBJ_;
+		_Event_String_Int_Int_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3f2bf266 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_String_Int_Int_Void")
+			{ 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.app._Event_String_Int_Int_Void"); }
+		static hx::ObjectPtr< _Event_String_Int_Int_Void_obj > __new();
+		static hx::ObjectPtr< _Event_String_Int_Int_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_String_Int_Int_Void_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_("_Event_String_Int_Int_Void",de,c1,ec,9a); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(::String a,int a1,int a2);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_String_Int_Int_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_String_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_String_Void
+#define INCLUDED_lime_app__Event_String_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_String_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_String_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_String_Void_obj OBJ_;
+		_Event_String_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x584e5dea };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_String_Void")
+			{ 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.app._Event_String_Void"); }
+		static hx::ObjectPtr< _Event_String_Void_obj > __new();
+		static hx::ObjectPtr< _Event_String_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_String_Void_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_("_Event_String_Void",7e,7e,48,a6); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(::String a);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_String_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_Void_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_Void_Void
+#define INCLUDED_lime_app__Event_Void_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_Void_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_Void_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_Void_Void_obj OBJ_;
+		_Event_Void_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0b08f687 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_Void_Void")
+			{ 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.app._Event_Void_Void"); }
+		static hx::ObjectPtr< _Event_Void_Void_obj > __new();
+		static hx::ObjectPtr< _Event_Void_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_Void_Void_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_("_Event_Void_Void",1b,0a,68,f4); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch();
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_Void_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_lime_graphics_RenderContext_Void.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_lime_graphics_RenderContext_Void
+#define INCLUDED_lime_app__Event_lime_graphics_RenderContext_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_lime_graphics_RenderContext_Void)
+HX_DECLARE_CLASS2(lime,graphics,RenderContext)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_lime_graphics_RenderContext_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_lime_graphics_RenderContext_Void_obj OBJ_;
+		_Event_lime_graphics_RenderContext_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x526b4304 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_lime_graphics_RenderContext_Void")
+			{ 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.app._Event_lime_graphics_RenderContext_Void"); }
+		static hx::ObjectPtr< _Event_lime_graphics_RenderContext_Void_obj > __new();
+		static hx::ObjectPtr< _Event_lime_graphics_RenderContext_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_lime_graphics_RenderContext_Void_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_("_Event_lime_graphics_RenderContext_Void",28,2f,e8,3f); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch( ::lime::graphics::RenderContext a);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_lime_graphics_RenderContext_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_lime_ui_GamepadAxis_Float_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_lime_ui_GamepadAxis_Float_Void
+#define INCLUDED_lime_app__Event_lime_ui_GamepadAxis_Float_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_lime_ui_GamepadAxis_Float_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_lime_ui_GamepadAxis_Float_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_lime_ui_GamepadAxis_Float_Void_obj OBJ_;
+		_Event_lime_ui_GamepadAxis_Float_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x02fd74b5 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_lime_ui_GamepadAxis_Float_Void")
+			{ 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.app._Event_lime_ui_GamepadAxis_Float_Void"); }
+		static hx::ObjectPtr< _Event_lime_ui_GamepadAxis_Float_Void_obj > __new();
+		static hx::ObjectPtr< _Event_lime_ui_GamepadAxis_Float_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_lime_ui_GamepadAxis_Float_Void_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_("_Event_lime_ui_GamepadAxis_Float_Void",99,c9,90,fe); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(int a,Float a1);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_lime_ui_GamepadAxis_Float_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_lime_ui_GamepadButton_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_lime_ui_GamepadButton_Void
+#define INCLUDED_lime_app__Event_lime_ui_GamepadButton_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_lime_ui_GamepadButton_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_lime_ui_GamepadButton_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_lime_ui_GamepadButton_Void_obj OBJ_;
+		_Event_lime_ui_GamepadButton_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x23f48759 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_lime_ui_GamepadButton_Void")
+			{ 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.app._Event_lime_ui_GamepadButton_Void"); }
+		static hx::ObjectPtr< _Event_lime_ui_GamepadButton_Void_obj > __new();
+		static hx::ObjectPtr< _Event_lime_ui_GamepadButton_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_lime_ui_GamepadButton_Void_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_("_Event_lime_ui_GamepadButton_Void",45,2d,36,cc); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(int a);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_lime_ui_GamepadButton_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_lime_ui_Gamepad_Void.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_lime_ui_Gamepad_Void
+#define INCLUDED_lime_app__Event_lime_ui_Gamepad_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_lime_ui_Gamepad_Void)
+HX_DECLARE_CLASS2(lime,ui,Gamepad)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_lime_ui_Gamepad_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_lime_ui_Gamepad_Void_obj OBJ_;
+		_Event_lime_ui_Gamepad_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x472d0cab };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_lime_ui_Gamepad_Void")
+			{ 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.app._Event_lime_ui_Gamepad_Void"); }
+		static hx::ObjectPtr< _Event_lime_ui_Gamepad_Void_obj > __new();
+		static hx::ObjectPtr< _Event_lime_ui_Gamepad_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_lime_ui_Gamepad_Void_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_("_Event_lime_ui_Gamepad_Void",97,39,fc,e3); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch( ::lime::ui::Gamepad a);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_lime_ui_Gamepad_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_lime_ui_Joystick_Void.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_lime_ui_Joystick_Void
+#define INCLUDED_lime_app__Event_lime_ui_Joystick_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_lime_ui_Joystick_Void)
+HX_DECLARE_CLASS2(lime,ui,Joystick)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_lime_ui_Joystick_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_lime_ui_Joystick_Void_obj OBJ_;
+		_Event_lime_ui_Joystick_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2d31a596 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_lime_ui_Joystick_Void")
+			{ 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.app._Event_lime_ui_Joystick_Void"); }
+		static hx::ObjectPtr< _Event_lime_ui_Joystick_Void_obj > __new();
+		static hx::ObjectPtr< _Event_lime_ui_Joystick_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_lime_ui_Joystick_Void_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_("_Event_lime_ui_Joystick_Void",f2,be,14,67); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch( ::lime::ui::Joystick a);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_lime_ui_Joystick_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void
+#define INCLUDED_lime_app__Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void_obj OBJ_;
+		_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7f02c176 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void")
+			{ 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.app._Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void"); }
+		static hx::ObjectPtr< _Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void_obj > __new();
+		static hx::ObjectPtr< _Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void_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_("_Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void",36,74,64,a0); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch(int a,int a1);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_lime_ui_KeyCode_lime_ui_KeyModifier_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_lime_ui_Touch_Void.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_lime_ui_Touch_Void
+#define INCLUDED_lime_app__Event_lime_ui_Touch_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_lime_ui_Touch_Void)
+HX_DECLARE_CLASS2(lime,ui,Touch)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_lime_ui_Touch_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_lime_ui_Touch_Void_obj OBJ_;
+		_Event_lime_ui_Touch_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0333a555 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_lime_ui_Touch_Void")
+			{ 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.app._Event_lime_ui_Touch_Void"); }
+		static hx::ObjectPtr< _Event_lime_ui_Touch_Void_obj > __new();
+		static hx::ObjectPtr< _Event_lime_ui_Touch_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_lime_ui_Touch_Void_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_("_Event_lime_ui_Touch_Void",79,5a,1b,af); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch( ::lime::ui::Touch a);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_lime_ui_Touch_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_lime_ui_Window_Void.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_lime_ui_Window_Void
+#define INCLUDED_lime_app__Event_lime_ui_Window_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_lime_ui_Window_Void)
+HX_DECLARE_CLASS2(lime,ui,Window)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_lime_ui_Window_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_lime_ui_Window_Void_obj OBJ_;
+		_Event_lime_ui_Window_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7c486306 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_lime_ui_Window_Void")
+			{ 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.app._Event_lime_ui_Window_Void"); }
+		static hx::ObjectPtr< _Event_lime_ui_Window_Void_obj > __new();
+		static hx::ObjectPtr< _Event_lime_ui_Window_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_lime_ui_Window_Void_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_("_Event_lime_ui_Window_Void",7e,32,09,d8); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch( ::lime::ui::Window a);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_lime_ui_Window_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Event_ofEvents_T_Void.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Event_ofEvents_T_Void
+#define INCLUDED_lime_app__Event_ofEvents_T_Void
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(lime,app,_Event_ofEvents_T_Void)
+
+namespace lime{
+namespace app{
+
+
+class HXCPP_CLASS_ATTRIBUTES _Event_ofEvents_T_Void_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef _Event_ofEvents_T_Void_obj OBJ_;
+		_Event_ofEvents_T_Void_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2d041bb6 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="lime.app._Event_ofEvents_T_Void")
+			{ 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.app._Event_ofEvents_T_Void"); }
+		static hx::ObjectPtr< _Event_ofEvents_T_Void_obj > __new();
+		static hx::ObjectPtr< _Event_ofEvents_T_Void_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~_Event_ofEvents_T_Void_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_("_Event_ofEvents_T_Void",4a,16,dc,09); }
+
+		bool canceled;
+		::Array< bool > _hx___repeat;
+		::Array< int > _hx___priorities;
+		void add( ::Dynamic listener,hx::Null< bool >  once,hx::Null< int >  priority);
+		::Dynamic add_dyn();
+
+		void cancel();
+		::Dynamic cancel_dyn();
+
+		bool has( ::Dynamic listener);
+		::Dynamic has_dyn();
+
+		void remove( ::Dynamic listener);
+		::Dynamic remove_dyn();
+
+		::Array< ::Dynamic> _hx___listeners;
+		void dispatch( ::Dynamic a);
+		::Dynamic dispatch_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+
+#endif /* INCLUDED_lime_app__Event_ofEvents_T_Void */ 

hGameTest/bin/linux/obj/include/lime/app/_Future/FutureWork.h

@@ -0,0 +1,76 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_lime_app__Future_FutureWork
+#define INCLUDED_lime_app__Future_FutureWork
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(lime,app,_Future,FutureWork)
+HX_DECLARE_CLASS2(lime,_hx_system,ThreadPool)
+
+namespace lime{
+namespace app{
+namespace _Future{
+
+
+class HXCPP_CLASS_ATTRIBUTES FutureWork_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef FutureWork_obj OBJ_;
+		FutureWork_obj();
+
+	public:
+		enum { _hx_ClassId = 0x594b82aa };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="lime.app._Future.FutureWork")
+			{ 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.app._Future.FutureWork"); }
+
+		inline static hx::ObjectPtr< FutureWork_obj > __new() {
+			hx::ObjectPtr< FutureWork_obj > __this = new FutureWork_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< FutureWork_obj > __alloc(hx::Ctx *_hx_ctx) {
+			FutureWork_obj *__this = (FutureWork_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(FutureWork_obj), false, "lime.app._Future.FutureWork"));
+			*(void **)__this = FutureWork_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~FutureWork_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_("FutureWork",d4,a7,da,de); }
+
+		static  ::lime::_hx_system::ThreadPool threadPool;
+		static void queue( ::Dynamic state);
+		static ::Dynamic queue_dyn();
+
+		static void threadPool_doWork( ::Dynamic state);
+		static ::Dynamic threadPool_doWork_dyn();
+
+		static void threadPool_onComplete( ::Dynamic state);
+		static ::Dynamic threadPool_onComplete_dyn();
+
+		static void threadPool_onError( ::Dynamic state);
+		static ::Dynamic threadPool_onError_dyn();
+
+};
+
+} // end namespace lime
+} // end namespace app
+} // end namespace _Future
+
+#endif /* INCLUDED_lime_app__Future_FutureWork */