First commit

hGameTest/bin/linux/obj/include/openfl/events/ActivityEvent.h

@@ -0,0 +1,63 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_ActivityEvent
+#define INCLUDED_openfl_events_ActivityEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_Event
+#include <openfl/events/Event.h>
+#endif
+HX_DECLARE_CLASS2(openfl,events,ActivityEvent)
+HX_DECLARE_CLASS2(openfl,events,Event)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES ActivityEvent_obj : public  ::openfl::events::Event_obj
+{
+	public:
+		typedef  ::openfl::events::Event_obj super;
+		typedef ActivityEvent_obj OBJ_;
+		ActivityEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x39a2f9a2 };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< bool >  __o_activating);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.ActivityEvent")
+			{ 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,"openfl.events.ActivityEvent"); }
+		static hx::ObjectPtr< ActivityEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< bool >  __o_activating);
+		static hx::ObjectPtr< ActivityEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< bool >  __o_activating);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ActivityEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ActivityEvent",ab,eb,0c,59); }
+
+		static void __boot();
+		static ::String ACTIVITY;
+		bool activating;
+		virtual  ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		virtual void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_ActivityEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/ErrorEvent.h

@@ -0,0 +1,64 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_ErrorEvent
+#define INCLUDED_openfl_events_ErrorEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_TextEvent
+#include <openfl/events/TextEvent.h>
+#endif
+HX_DECLARE_CLASS2(openfl,events,ErrorEvent)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,TextEvent)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES ErrorEvent_obj : public  ::openfl::events::TextEvent_obj
+{
+	public:
+		typedef  ::openfl::events::TextEvent_obj super;
+		typedef ErrorEvent_obj OBJ_;
+		ErrorEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x31935cfb };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,::String __o_text,hx::Null< int >  __o_id);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.ErrorEvent")
+			{ 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,"openfl.events.ErrorEvent"); }
+		static hx::ObjectPtr< ErrorEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,::String __o_text,hx::Null< int >  __o_id);
+		static hx::ObjectPtr< ErrorEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,::String __o_text,hx::Null< int >  __o_id);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ErrorEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ErrorEvent",52,bb,79,e1); }
+
+		static void __boot();
+		static ::String ERROR;
+		int errorID;
+		virtual  ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		virtual void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_ErrorEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/Event.h

@@ -0,0 +1,125 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_Event
+#define INCLUDED_openfl_events_Event
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,events,Event)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES Event_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Event_obj OBJ_;
+		Event_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3243040d };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.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,"openfl.events.Event"); }
+		static hx::ObjectPtr< Event_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable);
+		static hx::ObjectPtr< Event_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable);
+		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); }
+
+		static void __boot();
+		static ::String ACTIVATE;
+		static ::String ADDED;
+		static ::String ADDED_TO_STAGE;
+		static ::String CANCEL;
+		static ::String CHANGE;
+		static ::String CLEAR;
+		static ::String CLOSE;
+		static ::String COMPLETE;
+		static ::String CONNECT;
+		static ::String CONTEXT3D_CREATE;
+		static ::String COPY;
+		static ::String CUT;
+		static ::String DEACTIVATE;
+		static ::String ENTER_FRAME;
+		static ::String EXIT_FRAME;
+		static ::String FRAME_CONSTRUCTED;
+		static ::String FRAME_LABEL;
+		static ::String FULLSCREEN;
+		static ::String ID3;
+		static ::String INIT;
+		static ::String MOUSE_LEAVE;
+		static ::String OPEN;
+		static ::String PASTE;
+		static ::String REMOVED;
+		static ::String REMOVED_FROM_STAGE;
+		static ::String RENDER;
+		static ::String RESIZE;
+		static ::String SCROLL;
+		static ::String SELECT;
+		static ::String SELECT_ALL;
+		static ::String SOUND_COMPLETE;
+		static ::String TAB_CHILDREN_CHANGE;
+		static ::String TAB_ENABLED_CHANGE;
+		static ::String TAB_INDEX_CHANGE;
+		static ::String TEXTURE_READY;
+		static ::String UNLOAD;
+		bool bubbles;
+		bool cancelable;
+		 ::Dynamic currentTarget;
+		int eventPhase;
+		 ::Dynamic target;
+		::String type;
+		bool _hx___isCanceled;
+		bool _hx___isCanceledNow;
+		bool _hx___preventDefault;
+		virtual  ::openfl::events::Event clone();
+		::Dynamic clone_dyn();
+
+		::String formatToString(::String className,::String p1,::String p2,::String p3,::String p4,::String p5);
+		::Dynamic formatToString_dyn();
+
+		bool isDefaultPrevented();
+		::Dynamic isDefaultPrevented_dyn();
+
+		void preventDefault();
+		::Dynamic preventDefault_dyn();
+
+		void stopImmediatePropagation();
+		::Dynamic stopImmediatePropagation_dyn();
+
+		void stopPropagation();
+		::Dynamic stopPropagation_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		::String _hx___formatToString(::String className,::Array< ::String > parameters);
+		::Dynamic _hx___formatToString_dyn();
+
+		virtual void _hx___init();
+		::Dynamic _hx___init_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_Event */ 

hGameTest/bin/linux/obj/include/openfl/events/EventDispatcher.h

@@ -0,0 +1,91 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_EventDispatcher
+#define INCLUDED_openfl_events_EventDispatcher
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_IEventDispatcher
+#include <openfl/events/IEventDispatcher.h>
+#endif
+HX_DECLARE_CLASS1(haxe,IMap)
+HX_DECLARE_CLASS2(haxe,ds,StringMap)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS3(openfl,events,_EventDispatcher,Listener)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES EventDispatcher_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef EventDispatcher_obj OBJ_;
+		EventDispatcher_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1b123bf8 };
+
+		void __construct(::Dynamic target);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.EventDispatcher")
+			{ 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,"openfl.events.EventDispatcher"); }
+		static hx::ObjectPtr< EventDispatcher_obj > __new(::Dynamic target);
+		static hx::ObjectPtr< EventDispatcher_obj > __alloc(hx::Ctx *_hx_ctx,::Dynamic target);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~EventDispatcher_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_("EventDispatcher",41,82,63,5e); }
+
+		 ::haxe::ds::StringMap _hx___eventMap;
+		 ::haxe::ds::StringMap _hx___iterators;
+		::Dynamic _hx___targetDispatcher;
+		virtual void addEventListener(::String type, ::Dynamic listener,hx::Null< bool >  useCapture,hx::Null< int >  priority,hx::Null< bool >  useWeakReference);
+		::Dynamic addEventListener_dyn();
+
+		virtual bool dispatchEvent( ::openfl::events::Event event);
+		::Dynamic dispatchEvent_dyn();
+
+		bool hasEventListener(::String type);
+		::Dynamic hasEventListener_dyn();
+
+		virtual void removeEventListener(::String type, ::Dynamic listener,hx::Null< bool >  useCapture);
+		::Dynamic removeEventListener_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		bool willTrigger(::String type);
+		::Dynamic willTrigger_dyn();
+
+		virtual bool _hx___dispatchEvent( ::openfl::events::Event event);
+		::Dynamic _hx___dispatchEvent_dyn();
+
+		void _hx___removeAllListeners();
+		::Dynamic _hx___removeAllListeners_dyn();
+
+		void _hx___addListenerByPriority(::Array< ::Dynamic> list, ::openfl::events::_EventDispatcher::Listener listener);
+		::Dynamic _hx___addListenerByPriority_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_EventDispatcher */ 

hGameTest/bin/linux/obj/include/openfl/events/FocusEvent.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_FocusEvent
+#define INCLUDED_openfl_events_FocusEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_Event
+#include <openfl/events/Event.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,FocusEvent)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES FocusEvent_obj : public  ::openfl::events::Event_obj
+{
+	public:
+		typedef  ::openfl::events::Event_obj super;
+		typedef FocusEvent_obj OBJ_;
+		FocusEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7ef10eeb };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::openfl::display::InteractiveObject relatedObject,hx::Null< bool >  __o_shiftKey,hx::Null< int >  __o_keyCode);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.FocusEvent")
+			{ 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,"openfl.events.FocusEvent"); }
+		static hx::ObjectPtr< FocusEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::openfl::display::InteractiveObject relatedObject,hx::Null< bool >  __o_shiftKey,hx::Null< int >  __o_keyCode);
+		static hx::ObjectPtr< FocusEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::openfl::display::InteractiveObject relatedObject,hx::Null< bool >  __o_shiftKey,hx::Null< int >  __o_keyCode);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~FocusEvent_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_("FocusEvent",42,6d,d7,2e); }
+
+		static void __boot();
+		static ::String FOCUS_IN;
+		static ::String FOCUS_OUT;
+		static ::String KEY_FOCUS_CHANGE;
+		static ::String MOUSE_FOCUS_CHANGE;
+		int keyCode;
+		 ::openfl::display::InteractiveObject relatedObject;
+		bool shiftKey;
+		 ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_FocusEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/FullScreenEvent.h

@@ -0,0 +1,66 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_FullScreenEvent
+#define INCLUDED_openfl_events_FullScreenEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_ActivityEvent
+#include <openfl/events/ActivityEvent.h>
+#endif
+HX_DECLARE_CLASS2(openfl,events,ActivityEvent)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,FullScreenEvent)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES FullScreenEvent_obj : public  ::openfl::events::ActivityEvent_obj
+{
+	public:
+		typedef  ::openfl::events::ActivityEvent_obj super;
+		typedef FullScreenEvent_obj OBJ_;
+		FullScreenEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7ebe750e };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< bool >  __o_fullScreen,hx::Null< bool >  __o_interactive);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.FullScreenEvent")
+			{ 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,"openfl.events.FullScreenEvent"); }
+		static hx::ObjectPtr< FullScreenEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< bool >  __o_fullScreen,hx::Null< bool >  __o_interactive);
+		static hx::ObjectPtr< FullScreenEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< bool >  __o_fullScreen,hx::Null< bool >  __o_interactive);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~FullScreenEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FullScreenEvent",9f,a7,78,f1); }
+
+		static void __boot();
+		static ::String FULL_SCREEN;
+		static ::String FULL_SCREEN_INTERACTIVE_ACCEPTED;
+		bool fullScreen;
+		bool interactive;
+		 ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_FullScreenEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/GameInputEvent.h

@@ -0,0 +1,68 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_GameInputEvent
+#define INCLUDED_openfl_events_GameInputEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_Event
+#include <openfl/events/Event.h>
+#endif
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,GameInputEvent)
+HX_DECLARE_CLASS2(openfl,ui,GameInputDevice)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES GameInputEvent_obj : public  ::openfl::events::Event_obj
+{
+	public:
+		typedef  ::openfl::events::Event_obj super;
+		typedef GameInputEvent_obj OBJ_;
+		GameInputEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x1db74753 };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::openfl::ui::GameInputDevice device);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.GameInputEvent")
+			{ 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,"openfl.events.GameInputEvent"); }
+		static hx::ObjectPtr< GameInputEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::openfl::ui::GameInputDevice device);
+		static hx::ObjectPtr< GameInputEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::openfl::ui::GameInputDevice device);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~GameInputEvent_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_("GameInputEvent",62,3e,f4,2c); }
+
+		static void __boot();
+		static ::String DEVICE_ADDED;
+		static ::String DEVICE_REMOVED;
+		static ::String DEVICE_UNUSABLE;
+		 ::openfl::ui::GameInputDevice device;
+		 ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_GameInputEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/HTTPStatusEvent.h

@@ -0,0 +1,70 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_HTTPStatusEvent
+#define INCLUDED_openfl_events_HTTPStatusEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_Event
+#include <openfl/events/Event.h>
+#endif
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,HTTPStatusEvent)
+HX_DECLARE_CLASS2(openfl,net,URLRequestHeader)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES HTTPStatusEvent_obj : public  ::openfl::events::Event_obj
+{
+	public:
+		typedef  ::openfl::events::Event_obj super;
+		typedef HTTPStatusEvent_obj OBJ_;
+		HTTPStatusEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x7ed4634b };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< int >  __o_status,hx::Null< bool >  __o_redirected);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.HTTPStatusEvent")
+			{ 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,"openfl.events.HTTPStatusEvent"); }
+		static hx::ObjectPtr< HTTPStatusEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< int >  __o_status,hx::Null< bool >  __o_redirected);
+		static hx::ObjectPtr< HTTPStatusEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< int >  __o_status,hx::Null< bool >  __o_redirected);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~HTTPStatusEvent_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_("HTTPStatusEvent",e0,4c,1b,fe); }
+
+		static void __boot();
+		static ::String HTTP_RESPONSE_STATUS;
+		static ::String HTTP_STATUS;
+		bool redirected;
+		::Array< ::Dynamic> responseHeaders;
+		::String responseURL;
+		int status;
+		 ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_HTTPStatusEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/IEventDispatcher.h

@@ -0,0 +1,46 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_IEventDispatcher
+#define INCLUDED_openfl_events_IEventDispatcher
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES IEventDispatcher_obj {
+	public:
+		typedef hx::Object super;
+		HX_DO_INTERFACE_RTTI;
+
+		void (hx::Object :: *_hx_addEventListener)(::String type, ::Dynamic listener,hx::Null< bool >  useCapture,hx::Null< int >  priority,hx::Null< bool >  useWeakReference); 
+		static inline void addEventListener( ::Dynamic _hx_,::String type, ::Dynamic listener,hx::Null< bool >  useCapture,hx::Null< int >  priority,hx::Null< bool >  useWeakReference) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::events::IEventDispatcher_obj *>(_hx_.mPtr->_hx_getInterface(0x87530281)))->_hx_addEventListener)(type,listener,useCapture,priority,useWeakReference);
+		}
+		bool (hx::Object :: *_hx_dispatchEvent)( ::openfl::events::Event event); 
+		static inline bool dispatchEvent( ::Dynamic _hx_, ::openfl::events::Event event) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::events::IEventDispatcher_obj *>(_hx_.mPtr->_hx_getInterface(0x87530281)))->_hx_dispatchEvent)(event);
+		}
+		bool (hx::Object :: *_hx_hasEventListener)(::String type); 
+		static inline bool hasEventListener( ::Dynamic _hx_,::String type) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::events::IEventDispatcher_obj *>(_hx_.mPtr->_hx_getInterface(0x87530281)))->_hx_hasEventListener)(type);
+		}
+		void (hx::Object :: *_hx_removeEventListener)(::String type, ::Dynamic listener,hx::Null< bool >  useCapture); 
+		static inline void removeEventListener( ::Dynamic _hx_,::String type, ::Dynamic listener,hx::Null< bool >  useCapture) {
+			(_hx_.mPtr->*( hx::interface_cast< ::openfl::events::IEventDispatcher_obj *>(_hx_.mPtr->_hx_getInterface(0x87530281)))->_hx_removeEventListener)(type,listener,useCapture);
+		}
+		bool (hx::Object :: *_hx_willTrigger)(::String type); 
+		static inline bool willTrigger( ::Dynamic _hx_,::String type) {
+			return (_hx_.mPtr->*( hx::interface_cast< ::openfl::events::IEventDispatcher_obj *>(_hx_.mPtr->_hx_getInterface(0x87530281)))->_hx_willTrigger)(type);
+		}
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_IEventDispatcher */ 

hGameTest/bin/linux/obj/include/openfl/events/IOErrorEvent.h

@@ -0,0 +1,60 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_IOErrorEvent
+#define INCLUDED_openfl_events_IOErrorEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_ErrorEvent
+#include <openfl/events/ErrorEvent.h>
+#endif
+HX_DECLARE_CLASS2(openfl,events,ErrorEvent)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,IOErrorEvent)
+HX_DECLARE_CLASS2(openfl,events,TextEvent)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES IOErrorEvent_obj : public  ::openfl::events::ErrorEvent_obj
+{
+	public:
+		typedef  ::openfl::events::ErrorEvent_obj super;
+		typedef IOErrorEvent_obj OBJ_;
+		IOErrorEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x28b734a1 };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,::String __o_text,hx::Null< int >  __o_id);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.IOErrorEvent")
+			{ 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,"openfl.events.IOErrorEvent"); }
+		static hx::ObjectPtr< IOErrorEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,::String __o_text,hx::Null< int >  __o_id);
+		static hx::ObjectPtr< IOErrorEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,::String __o_text,hx::Null< int >  __o_id);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~IOErrorEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("IOErrorEvent",b8,16,b3,65); }
+
+		static void __boot();
+		static ::String IO_ERROR;
+		 ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_IOErrorEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/KeyboardEvent.h

@@ -0,0 +1,71 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_KeyboardEvent
+#define INCLUDED_openfl_events_KeyboardEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_Event
+#include <openfl/events/Event.h>
+#endif
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,KeyboardEvent)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES KeyboardEvent_obj : public  ::openfl::events::Event_obj
+{
+	public:
+		typedef  ::openfl::events::Event_obj super;
+		typedef KeyboardEvent_obj OBJ_;
+		KeyboardEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x721e9bca };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< int >  __o_charCodeValue,hx::Null< int >  __o_keyCodeValue, ::Dynamic keyLocationValue,hx::Null< bool >  __o_ctrlKeyValue,hx::Null< bool >  __o_altKeyValue,hx::Null< bool >  __o_shiftKeyValue,hx::Null< bool >  __o_controlKeyValue,hx::Null< bool >  __o_commandKeyValue);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.KeyboardEvent")
+			{ 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,"openfl.events.KeyboardEvent"); }
+		static hx::ObjectPtr< KeyboardEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< int >  __o_charCodeValue,hx::Null< int >  __o_keyCodeValue, ::Dynamic keyLocationValue,hx::Null< bool >  __o_ctrlKeyValue,hx::Null< bool >  __o_altKeyValue,hx::Null< bool >  __o_shiftKeyValue,hx::Null< bool >  __o_controlKeyValue,hx::Null< bool >  __o_commandKeyValue);
+		static hx::ObjectPtr< KeyboardEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< int >  __o_charCodeValue,hx::Null< int >  __o_keyCodeValue, ::Dynamic keyLocationValue,hx::Null< bool >  __o_ctrlKeyValue,hx::Null< bool >  __o_altKeyValue,hx::Null< bool >  __o_shiftKeyValue,hx::Null< bool >  __o_controlKeyValue,hx::Null< bool >  __o_commandKeyValue);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~KeyboardEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("KeyboardEvent",d3,8d,88,91); }
+
+		static void __boot();
+		static ::String KEY_DOWN;
+		static ::String KEY_UP;
+		bool altKey;
+		int charCode;
+		bool commandKey;
+		bool controlKey;
+		bool ctrlKey;
+		int keyCode;
+		int keyLocation;
+		bool shiftKey;
+		 ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_KeyboardEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/MouseEvent.h

@@ -0,0 +1,112 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_MouseEvent
+#define INCLUDED_openfl_events_MouseEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_Event
+#include <openfl/events/Event.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,MouseEvent)
+HX_DECLARE_CLASS2(openfl,geom,Point)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES MouseEvent_obj : public  ::openfl::events::Event_obj
+{
+	public:
+		typedef  ::openfl::events::Event_obj super;
+		typedef MouseEvent_obj OBJ_;
+		MouseEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x05564ee2 };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< Float >  __o_localX,hx::Null< Float >  __o_localY, ::openfl::display::InteractiveObject relatedObject,hx::Null< bool >  __o_ctrlKey,hx::Null< bool >  __o_altKey,hx::Null< bool >  __o_shiftKey,hx::Null< bool >  __o_buttonDown,hx::Null< int >  __o_delta,hx::Null< bool >  __o_commandKey,hx::Null< int >  __o_clickCount);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.MouseEvent")
+			{ 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,"openfl.events.MouseEvent"); }
+		static hx::ObjectPtr< MouseEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< Float >  __o_localX,hx::Null< Float >  __o_localY, ::openfl::display::InteractiveObject relatedObject,hx::Null< bool >  __o_ctrlKey,hx::Null< bool >  __o_altKey,hx::Null< bool >  __o_shiftKey,hx::Null< bool >  __o_buttonDown,hx::Null< int >  __o_delta,hx::Null< bool >  __o_commandKey,hx::Null< int >  __o_clickCount);
+		static hx::ObjectPtr< MouseEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< Float >  __o_localX,hx::Null< Float >  __o_localY, ::openfl::display::InteractiveObject relatedObject,hx::Null< bool >  __o_ctrlKey,hx::Null< bool >  __o_altKey,hx::Null< bool >  __o_shiftKey,hx::Null< bool >  __o_buttonDown,hx::Null< int >  __o_delta,hx::Null< bool >  __o_commandKey,hx::Null< int >  __o_clickCount);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~MouseEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("MouseEvent",d5,bf,42,8a); }
+
+		static void __boot();
+		static ::String CLICK;
+		static ::String DOUBLE_CLICK;
+		static ::String MIDDLE_CLICK;
+		static ::String MIDDLE_MOUSE_DOWN;
+		static ::String MIDDLE_MOUSE_UP;
+		static ::String MOUSE_DOWN;
+		static ::String MOUSE_MOVE;
+		static ::String MOUSE_OUT;
+		static ::String MOUSE_OVER;
+		static ::String MOUSE_UP;
+		static ::String MOUSE_WHEEL;
+		static ::String RELEASE_OUTSIDE;
+		static ::String RIGHT_CLICK;
+		static ::String RIGHT_MOUSE_DOWN;
+		static ::String RIGHT_MOUSE_UP;
+		static ::String ROLL_OUT;
+		static ::String ROLL_OVER;
+		static bool _hx___altKey;
+		static bool _hx___buttonDown;
+		static bool _hx___commandKey;
+		static bool _hx___ctrlKey;
+		static bool _hx___shiftKey;
+		static  ::openfl::events::MouseEvent _hx___create(::String type,int button,Float stageX,Float stageY, ::openfl::geom::Point local, ::openfl::display::InteractiveObject target,hx::Null< int >  delta);
+		static ::Dynamic _hx___create_dyn();
+
+		bool altKey;
+		bool buttonDown;
+		bool commandKey;
+		int clickCount;
+		bool ctrlKey;
+		int delta;
+		bool isRelatedObjectInaccessible;
+		Float localX;
+		Float localY;
+		 ::openfl::display::InteractiveObject relatedObject;
+		bool shiftKey;
+		Float stageX;
+		Float stageY;
+		 ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		void updateAfterEvent();
+		::Dynamic updateAfterEvent_dyn();
+
+		void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_MouseEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/NetStatusEvent.h

@@ -0,0 +1,65 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_NetStatusEvent
+#define INCLUDED_openfl_events_NetStatusEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_Event
+#include <openfl/events/Event.h>
+#endif
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,NetStatusEvent)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES NetStatusEvent_obj : public  ::openfl::events::Event_obj
+{
+	public:
+		typedef  ::openfl::events::Event_obj super;
+		typedef NetStatusEvent_obj OBJ_;
+		NetStatusEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0ab05474 };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::Dynamic info);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.NetStatusEvent")
+			{ 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,"openfl.events.NetStatusEvent"); }
+		static hx::ObjectPtr< NetStatusEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::Dynamic info);
+		static hx::ObjectPtr< NetStatusEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::Dynamic info);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~NetStatusEvent_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_("NetStatusEvent",4b,2a,fa,67); }
+
+		static void __boot();
+		static ::String NET_STATUS;
+		 ::Dynamic info;
+		 ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_NetStatusEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/ProgressEvent.h

@@ -0,0 +1,65 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_ProgressEvent
+#define INCLUDED_openfl_events_ProgressEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_Event
+#include <openfl/events/Event.h>
+#endif
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,ProgressEvent)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES ProgressEvent_obj : public  ::openfl::events::Event_obj
+{
+	public:
+		typedef  ::openfl::events::Event_obj super;
+		typedef ProgressEvent_obj OBJ_;
+		ProgressEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x64ebab04 };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< Float >  __o_bytesLoaded,hx::Null< Float >  __o_bytesTotal);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.ProgressEvent")
+			{ 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,"openfl.events.ProgressEvent"); }
+		static hx::ObjectPtr< ProgressEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< Float >  __o_bytesLoaded,hx::Null< Float >  __o_bytesTotal);
+		static hx::ObjectPtr< ProgressEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< Float >  __o_bytesLoaded,hx::Null< Float >  __o_bytesTotal);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~ProgressEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("ProgressEvent",0d,9d,55,84); }
+
+		static void __boot();
+		static ::String PROGRESS;
+		static ::String SOCKET_DATA;
+		Float bytesLoaded;
+		Float bytesTotal;
+		 ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_ProgressEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/RenderEvent.h

@@ -0,0 +1,77 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_RenderEvent
+#define INCLUDED_openfl_events_RenderEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_Event
+#include <openfl/events/Event.h>
+#endif
+HX_DECLARE_CLASS2(openfl,display,DisplayObjectRenderer)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,RenderEvent)
+HX_DECLARE_CLASS2(openfl,geom,ColorTransform)
+HX_DECLARE_CLASS2(openfl,geom,Matrix)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES RenderEvent_obj : public  ::openfl::events::Event_obj
+{
+	public:
+		typedef  ::openfl::events::Event_obj super;
+		typedef RenderEvent_obj OBJ_;
+		RenderEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5bb22917 };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::openfl::geom::Matrix objectMatrix, ::openfl::geom::ColorTransform objectColorTransform,hx::Null< bool >  __o_allowSmoothing);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.RenderEvent")
+			{ 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,"openfl.events.RenderEvent"); }
+		static hx::ObjectPtr< RenderEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::openfl::geom::Matrix objectMatrix, ::openfl::geom::ColorTransform objectColorTransform,hx::Null< bool >  __o_allowSmoothing);
+		static hx::ObjectPtr< RenderEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::openfl::geom::Matrix objectMatrix, ::openfl::geom::ColorTransform objectColorTransform,hx::Null< bool >  __o_allowSmoothing);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~RenderEvent_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_("RenderEvent",c4,8c,a8,25); }
+
+		static void __boot();
+		static ::String CLEAR_DOM;
+		static ::String RENDER_CAIRO;
+		static ::String RENDER_CANVAS;
+		static ::String RENDER_DOM;
+		static ::String RENDER_OPENGL;
+		bool allowSmoothing;
+		 ::openfl::geom::ColorTransform objectColorTransform;
+		 ::openfl::geom::Matrix objectMatrix;
+		 ::openfl::display::DisplayObjectRenderer renderer;
+		 ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_RenderEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/SecurityErrorEvent.h

@@ -0,0 +1,60 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_SecurityErrorEvent
+#define INCLUDED_openfl_events_SecurityErrorEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_ErrorEvent
+#include <openfl/events/ErrorEvent.h>
+#endif
+HX_DECLARE_CLASS2(openfl,events,ErrorEvent)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,SecurityErrorEvent)
+HX_DECLARE_CLASS2(openfl,events,TextEvent)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES SecurityErrorEvent_obj : public  ::openfl::events::ErrorEvent_obj
+{
+	public:
+		typedef  ::openfl::events::ErrorEvent_obj super;
+		typedef SecurityErrorEvent_obj OBJ_;
+		SecurityErrorEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x4733dcdb };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,::String __o_text,hx::Null< int >  __o_id);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.SecurityErrorEvent")
+			{ 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,"openfl.events.SecurityErrorEvent"); }
+		static hx::ObjectPtr< SecurityErrorEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,::String __o_text,hx::Null< int >  __o_id);
+		static hx::ObjectPtr< SecurityErrorEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,::String __o_text,hx::Null< int >  __o_id);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~SecurityErrorEvent_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("SecurityErrorEvent",32,ea,b2,a1); }
+
+		static void __boot();
+		static ::String SECURITY_ERROR;
+		 ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_SecurityErrorEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/TextEvent.h

@@ -0,0 +1,66 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_TextEvent
+#define INCLUDED_openfl_events_TextEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_Event
+#include <openfl/events/Event.h>
+#endif
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,TextEvent)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES TextEvent_obj : public  ::openfl::events::Event_obj
+{
+	public:
+		typedef  ::openfl::events::Event_obj super;
+		typedef TextEvent_obj OBJ_;
+		TextEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x70c909a0 };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,::String __o_text);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.TextEvent")
+			{ 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,"openfl.events.TextEvent"); }
+		static hx::ObjectPtr< TextEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,::String __o_text);
+		static hx::ObjectPtr< TextEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,::String __o_text);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~TextEvent_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_("TextEvent",0d,38,85,b0); }
+
+		static void __boot();
+		static ::String LINK;
+		static ::String TEXT_INPUT;
+		::String text;
+		virtual  ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		virtual void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_TextEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/TouchEvent.h

@@ -0,0 +1,105 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_TouchEvent
+#define INCLUDED_openfl_events_TouchEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_Event
+#include <openfl/events/Event.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(openfl,display,DisplayObject)
+HX_DECLARE_CLASS2(openfl,display,IBitmapDrawable)
+HX_DECLARE_CLASS2(openfl,display,InteractiveObject)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,TouchEvent)
+HX_DECLARE_CLASS2(openfl,geom,Point)
+HX_DECLARE_CLASS2(openfl,utils,ByteArrayData)
+HX_DECLARE_CLASS2(openfl,utils,IDataInput)
+HX_DECLARE_CLASS2(openfl,utils,IDataOutput)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES TouchEvent_obj : public  ::openfl::events::Event_obj
+{
+	public:
+		typedef  ::openfl::events::Event_obj super;
+		typedef TouchEvent_obj OBJ_;
+		TouchEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0c142c6c };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< int >  __o_touchPointID,hx::Null< bool >  __o_isPrimaryTouchPoint,hx::Null< Float >  __o_localX,hx::Null< Float >  __o_localY,hx::Null< Float >  __o_sizeX,hx::Null< Float >  __o_sizeY,hx::Null< Float >  __o_pressure, ::openfl::display::InteractiveObject relatedObject,hx::Null< bool >  __o_ctrlKey,hx::Null< bool >  __o_altKey,hx::Null< bool >  __o_shiftKey,hx::Null< bool >  __o_commandKey,hx::Null< bool >  __o_controlKey,hx::Null< Float >  __o_timestamp,::String touchIntent, ::openfl::utils::ByteArrayData samples,hx::Null< bool >  __o_isTouchPointCanceled);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.TouchEvent")
+			{ 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,"openfl.events.TouchEvent"); }
+		static hx::ObjectPtr< TouchEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< int >  __o_touchPointID,hx::Null< bool >  __o_isPrimaryTouchPoint,hx::Null< Float >  __o_localX,hx::Null< Float >  __o_localY,hx::Null< Float >  __o_sizeX,hx::Null< Float >  __o_sizeY,hx::Null< Float >  __o_pressure, ::openfl::display::InteractiveObject relatedObject,hx::Null< bool >  __o_ctrlKey,hx::Null< bool >  __o_altKey,hx::Null< bool >  __o_shiftKey,hx::Null< bool >  __o_commandKey,hx::Null< bool >  __o_controlKey,hx::Null< Float >  __o_timestamp,::String touchIntent, ::openfl::utils::ByteArrayData samples,hx::Null< bool >  __o_isTouchPointCanceled);
+		static hx::ObjectPtr< TouchEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable,hx::Null< int >  __o_touchPointID,hx::Null< bool >  __o_isPrimaryTouchPoint,hx::Null< Float >  __o_localX,hx::Null< Float >  __o_localY,hx::Null< Float >  __o_sizeX,hx::Null< Float >  __o_sizeY,hx::Null< Float >  __o_pressure, ::openfl::display::InteractiveObject relatedObject,hx::Null< bool >  __o_ctrlKey,hx::Null< bool >  __o_altKey,hx::Null< bool >  __o_shiftKey,hx::Null< bool >  __o_commandKey,hx::Null< bool >  __o_controlKey,hx::Null< Float >  __o_timestamp,::String touchIntent, ::openfl::utils::ByteArrayData samples,hx::Null< bool >  __o_isTouchPointCanceled);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~TouchEvent_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_("TouchEvent",fb,af,06,66); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		static ::String TOUCH_BEGIN;
+		static ::String TOUCH_END;
+		static ::String TOUCH_MOVE;
+		static ::String TOUCH_OUT;
+		static ::String TOUCH_OVER;
+		static ::String TOUCH_ROLL_OUT;
+		static ::String TOUCH_ROLL_OVER;
+		static ::String TOUCH_TAP;
+		static  ::openfl::events::TouchEvent _hx___create(::String type, ::Dynamic touch,Float stageX,Float stageY, ::openfl::geom::Point local, ::openfl::display::InteractiveObject target);
+		static ::Dynamic _hx___create_dyn();
+
+		bool altKey;
+		bool commandKey;
+		bool controlKey;
+		bool ctrlKey;
+		int delta;
+		bool isPrimaryTouchPoint;
+		Float localX;
+		Float localY;
+		Float pressure;
+		 ::openfl::display::InteractiveObject relatedObject;
+		bool shiftKey;
+		Float sizeX;
+		Float sizeY;
+		Float stageX;
+		Float stageY;
+		int touchPointID;
+		 ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		void updateAfterEvent();
+		::Dynamic updateAfterEvent_dyn();
+
+		void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_TouchEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/UncaughtErrorEvent.h

@@ -0,0 +1,67 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_UncaughtErrorEvent
+#define INCLUDED_openfl_events_UncaughtErrorEvent
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_ErrorEvent
+#include <openfl/events/ErrorEvent.h>
+#endif
+HX_DECLARE_CLASS2(openfl,events,ErrorEvent)
+HX_DECLARE_CLASS2(openfl,events,Event)
+HX_DECLARE_CLASS2(openfl,events,TextEvent)
+HX_DECLARE_CLASS2(openfl,events,UncaughtErrorEvent)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES UncaughtErrorEvent_obj : public  ::openfl::events::ErrorEvent_obj
+{
+	public:
+		typedef  ::openfl::events::ErrorEvent_obj super;
+		typedef UncaughtErrorEvent_obj OBJ_;
+		UncaughtErrorEvent_obj();
+
+	public:
+		enum { _hx_ClassId = 0x178f391c };
+
+		void __construct(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::Dynamic error);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.UncaughtErrorEvent")
+			{ 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,"openfl.events.UncaughtErrorEvent"); }
+		static hx::ObjectPtr< UncaughtErrorEvent_obj > __new(::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::Dynamic error);
+		static hx::ObjectPtr< UncaughtErrorEvent_obj > __alloc(hx::Ctx *_hx_ctx,::String type,hx::Null< bool >  __o_bubbles,hx::Null< bool >  __o_cancelable, ::Dynamic error);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~UncaughtErrorEvent_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_("UncaughtErrorEvent",47,72,9a,e0); }
+
+		static void __boot();
+		static ::String UNCAUGHT_ERROR;
+		 ::Dynamic error;
+		 ::openfl::events::Event clone();
+
+		virtual ::String toString();
+
+		void _hx___init();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_UncaughtErrorEvent */ 

hGameTest/bin/linux/obj/include/openfl/events/UncaughtErrorEvents.h

@@ -0,0 +1,52 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events_UncaughtErrorEvents
+#define INCLUDED_openfl_events_UncaughtErrorEvents
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_openfl_events_EventDispatcher
+#include <openfl/events/EventDispatcher.h>
+#endif
+HX_DECLARE_CLASS2(openfl,events,EventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,IEventDispatcher)
+HX_DECLARE_CLASS2(openfl,events,UncaughtErrorEvents)
+
+namespace openfl{
+namespace events{
+
+
+class HXCPP_CLASS_ATTRIBUTES UncaughtErrorEvents_obj : public  ::openfl::events::EventDispatcher_obj
+{
+	public:
+		typedef  ::openfl::events::EventDispatcher_obj super;
+		typedef UncaughtErrorEvents_obj OBJ_;
+		UncaughtErrorEvents_obj();
+
+	public:
+		enum { _hx_ClassId = 0x0dd4339f };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events.UncaughtErrorEvents")
+			{ 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,"openfl.events.UncaughtErrorEvents"); }
+		static hx::ObjectPtr< UncaughtErrorEvents_obj > __new();
+		static hx::ObjectPtr< UncaughtErrorEvents_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~UncaughtErrorEvents_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("UncaughtErrorEvents",4c,8c,89,a6); }
+
+};
+
+} // end namespace openfl
+} // end namespace events
+
+#endif /* INCLUDED_openfl_events_UncaughtErrorEvents */ 

hGameTest/bin/linux/obj/include/openfl/events/_EventDispatcher/DispatchIterator.h

@@ -0,0 +1,82 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events__EventDispatcher_DispatchIterator
+#define INCLUDED_openfl_events__EventDispatcher_DispatchIterator
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,events,_EventDispatcher,DispatchIterator)
+HX_DECLARE_CLASS3(openfl,events,_EventDispatcher,Listener)
+
+namespace openfl{
+namespace events{
+namespace _EventDispatcher{
+
+
+class HXCPP_CLASS_ATTRIBUTES DispatchIterator_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef DispatchIterator_obj OBJ_;
+		DispatchIterator_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5770525b };
+
+		void __construct(::Array< ::Dynamic> list);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events._EventDispatcher.DispatchIterator")
+			{ 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,"openfl.events._EventDispatcher.DispatchIterator"); }
+		static hx::ObjectPtr< DispatchIterator_obj > __new(::Array< ::Dynamic> list);
+		static hx::ObjectPtr< DispatchIterator_obj > __alloc(hx::Ctx *_hx_ctx,::Array< ::Dynamic> list);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~DispatchIterator_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_("DispatchIterator",e8,fa,8e,c6); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		bool active;
+		int index;
+		bool isCopy;
+		::Array< ::Dynamic> list;
+		void copy();
+		::Dynamic copy_dyn();
+
+		bool hasNext();
+		::Dynamic hasNext_dyn();
+
+		 ::openfl::events::_EventDispatcher::Listener next();
+		::Dynamic next_dyn();
+
+		void remove( ::openfl::events::_EventDispatcher::Listener listener,int listIndex);
+		::Dynamic remove_dyn();
+
+		void reset(::Array< ::Dynamic> list);
+		::Dynamic reset_dyn();
+
+		void start();
+		::Dynamic start_dyn();
+
+		void stop();
+		::Dynamic stop_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+} // end namespace _EventDispatcher
+
+#endif /* INCLUDED_openfl_events__EventDispatcher_DispatchIterator */ 

hGameTest/bin/linux/obj/include/openfl/events/_EventDispatcher/Listener.h

@@ -0,0 +1,63 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events__EventDispatcher_Listener
+#define INCLUDED_openfl_events__EventDispatcher_Listener
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,events,_EventDispatcher,Listener)
+
+namespace openfl{
+namespace events{
+namespace _EventDispatcher{
+
+
+class HXCPP_CLASS_ATTRIBUTES Listener_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Listener_obj OBJ_;
+		Listener_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2c02fe3f };
+
+		void __construct( ::Dynamic callback,bool useCapture,int priority);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="openfl.events._EventDispatcher.Listener")
+			{ 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,"openfl.events._EventDispatcher.Listener"); }
+		static hx::ObjectPtr< Listener_obj > __new( ::Dynamic callback,bool useCapture,int priority);
+		static hx::ObjectPtr< Listener_obj > __alloc(hx::Ctx *_hx_ctx, ::Dynamic callback,bool useCapture,int priority);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Listener_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_("Listener",94,bc,e3,11); }
+
+		static void __boot();
+		static  ::Dynamic __meta__;
+		 ::Dynamic callback;
+		Dynamic callback_dyn() { return callback;}
+		int priority;
+		bool useCapture;
+		bool match( ::Dynamic callback,bool useCapture);
+		::Dynamic match_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+} // end namespace _EventDispatcher
+
+#endif /* INCLUDED_openfl_events__EventDispatcher_Listener */ 

hGameTest/bin/linux/obj/include/openfl/events/_EventType/EventType_Impl_.h

@@ -0,0 +1,67 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_openfl_events__EventType_EventType_Impl_
+#define INCLUDED_openfl_events__EventType_EventType_Impl_
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS3(openfl,events,_EventType,EventType_Impl_)
+
+namespace openfl{
+namespace events{
+namespace _EventType{
+
+
+class HXCPP_CLASS_ATTRIBUTES EventType_Impl__obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef EventType_Impl__obj OBJ_;
+		EventType_Impl__obj();
+
+	public:
+		enum { _hx_ClassId = 0x467117d2 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="openfl.events._EventType.EventType_Impl_")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"openfl.events._EventType.EventType_Impl_"); }
+
+		inline static hx::ObjectPtr< EventType_Impl__obj > __new() {
+			hx::ObjectPtr< EventType_Impl__obj > __this = new EventType_Impl__obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< EventType_Impl__obj > __alloc(hx::Ctx *_hx_ctx) {
+			EventType_Impl__obj *__this = (EventType_Impl__obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(EventType_Impl__obj), false, "openfl.events._EventType.EventType_Impl_"));
+			*(void **)__this = EventType_Impl__obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~EventType_Impl__obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("EventType_Impl_",74,af,ce,94); }
+
+		static bool equals(::String a,::String b);
+		static ::Dynamic equals_dyn();
+
+		static bool notEquals(::String a,::String b);
+		static ::Dynamic notEquals_dyn();
+
+};
+
+} // end namespace openfl
+} // end namespace events
+} // end namespace _EventType
+
+#endif /* INCLUDED_openfl_events__EventType_EventType_Impl_ */