Example #1
0
        static StackObject *Play_4(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            StackObject *ptr_of_this_method;
            StackObject *__ret = ILIntepreter.Minus(__esp, 6);

            ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
            FairyGUI.PlayCompleteCallback @onComplete = (FairyGUI.PlayCompleteCallback) typeof(FairyGUI.PlayCompleteCallback).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
            __intp.Free(ptr_of_this_method);

            ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
            System.Single @endTime = *(float *)&ptr_of_this_method->Value;

            ptr_of_this_method = ILIntepreter.Minus(__esp, 3);
            System.Single @startTime = *(float *)&ptr_of_this_method->Value;

            ptr_of_this_method = ILIntepreter.Minus(__esp, 4);
            System.Single @delay = *(float *)&ptr_of_this_method->Value;

            ptr_of_this_method = ILIntepreter.Minus(__esp, 5);
            System.Int32 @times = ptr_of_this_method->Value;

            ptr_of_this_method = ILIntepreter.Minus(__esp, 6);
            FairyGUI.Transition instance_of_this_method = (FairyGUI.Transition) typeof(FairyGUI.Transition).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
            __intp.Free(ptr_of_this_method);

            instance_of_this_method.Play(@times, @delay, @startTime, @endTime, @onComplete);

            return(__ret);
        }
        static internal int checkDelegate(IntPtr l, int p, out FairyGUI.PlayCompleteCallback ua)
        {
            int op = extractFunction(l, p);

            if (LuaDLL.lua_isnil(l, p))
            {
                ua = null;
                return(op);
            }
            else if (LuaDLL.lua_isuserdata(l, p) == 1)
            {
                ua = (FairyGUI.PlayCompleteCallback)checkObj(l, p);
                return(op);
            }
            LuaDelegate ld;

            checkType(l, -1, out ld);
            if (ld.d != null)
            {
                ua = (FairyGUI.PlayCompleteCallback)ld.d;
                return(op);
            }
            LuaDLL.lua_pop(l, 1);

            l  = LuaState.get(l).L;
            ua = () =>
            {
                int error = pushTry(l);

                ld.pcall(0, error);
                LuaDLL.lua_settop(l, error - 1);
            };
            ld.d = ua;
            return(op);
        }
Example #3
0
    public static Delegate FairyGUI_PlayCompleteCallback(LuaFunction func)
    {
        if (func == null)
        {
            FairyGUI.PlayCompleteCallback fn = delegate { };
            return(fn);
        }

        FairyGUI.PlayCompleteCallback d = (new FairyGUI_PlayCompleteCallback_Event(func)).Call;
        return(d);
    }
        static int _m_PlayReverse(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


                FairyGUI.Transition gen_to_be_invoked = (FairyGUI.Transition)translator.FastGetCSObj(L, 1);


                int gen_param_count = LuaAPI.lua_gettop(L);

                if (gen_param_count == 1)
                {
                    gen_to_be_invoked.PlayReverse(  );



                    return(0);
                }
                if (gen_param_count == 2 && translator.Assignable <FairyGUI.PlayCompleteCallback>(L, 2))
                {
                    FairyGUI.PlayCompleteCallback _onComplete = translator.GetDelegate <FairyGUI.PlayCompleteCallback>(L, 2);

                    gen_to_be_invoked.PlayReverse(
                        _onComplete);



                    return(0);
                }
                if (gen_param_count == 4 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable <FairyGUI.PlayCompleteCallback>(L, 4))
                {
                    int   _times = LuaAPI.xlua_tointeger(L, 2);
                    float _delay = (float)LuaAPI.lua_tonumber(L, 3);
                    FairyGUI.PlayCompleteCallback _onComplete = translator.GetDelegate <FairyGUI.PlayCompleteCallback>(L, 4);

                    gen_to_be_invoked.PlayReverse(
                        _times,
                        _delay,
                        _onComplete);



                    return(0);
                }
            } catch (System.Exception gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
            }

            return(LuaAPI.luaL_error(L, "invalid arguments to FairyGUI.Transition.PlayReverse!"));
        }
    static int Play(IntPtr L)
    {
        try
        {
            int count = LuaDLL.lua_gettop(L);

            if (count == 1)
            {
                FairyGUI.Transition obj = (FairyGUI.Transition)ToLua.CheckObject <FairyGUI.Transition>(L, 1);
                obj.Play();
                return(0);
            }
            else if (count == 2)
            {
                FairyGUI.Transition           obj  = (FairyGUI.Transition)ToLua.CheckObject <FairyGUI.Transition>(L, 1);
                FairyGUI.PlayCompleteCallback arg0 = (FairyGUI.PlayCompleteCallback)ToLua.CheckDelegate <FairyGUI.PlayCompleteCallback>(L, 2);
                obj.Play(arg0);
                return(0);
            }
            else if (count == 4)
            {
                FairyGUI.Transition obj = (FairyGUI.Transition)ToLua.CheckObject <FairyGUI.Transition>(L, 1);
                int   arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
                float arg1 = (float)LuaDLL.luaL_checknumber(L, 3);
                FairyGUI.PlayCompleteCallback arg2 = (FairyGUI.PlayCompleteCallback)ToLua.CheckDelegate <FairyGUI.PlayCompleteCallback>(L, 4);
                obj.Play(arg0, arg1, arg2);
                return(0);
            }
            else if (count == 6)
            {
                FairyGUI.Transition obj = (FairyGUI.Transition)ToLua.CheckObject <FairyGUI.Transition>(L, 1);
                int   arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
                float arg1 = (float)LuaDLL.luaL_checknumber(L, 3);
                float arg2 = (float)LuaDLL.luaL_checknumber(L, 4);
                float arg3 = (float)LuaDLL.luaL_checknumber(L, 5);
                FairyGUI.PlayCompleteCallback arg4 = (FairyGUI.PlayCompleteCallback)ToLua.CheckDelegate <FairyGUI.PlayCompleteCallback>(L, 6);
                obj.Play(arg0, arg1, arg2, arg3, arg4);
                return(0);
            }
            else
            {
                return(LuaDLL.luaL_throw(L, "invalid arguments to method: FairyGUI.Transition.Play"));
            }
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }
Example #6
0
        static StackObject *PlayReverse_6(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            StackObject *ptr_of_this_method;
            StackObject *__ret = ILIntepreter.Minus(__esp, 2);

            ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
            FairyGUI.PlayCompleteCallback @onComplete = (FairyGUI.PlayCompleteCallback) typeof(FairyGUI.PlayCompleteCallback).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
            __intp.Free(ptr_of_this_method);

            ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
            FairyGUI.Transition instance_of_this_method = (FairyGUI.Transition) typeof(FairyGUI.Transition).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
            __intp.Free(ptr_of_this_method);

            instance_of_this_method.PlayReverse(@onComplete);

            return(__ret);
        }
Example #7
0
    public static Delegate FairyGUI_PlayCompleteCallback(LuaFunction func, LuaTable self, bool flag)
    {
        if (func == null)
        {
            FairyGUI.PlayCompleteCallback fn = delegate() { };
            return(fn);
        }

        if (!flag)
        {
            FairyGUI.PlayCompleteCallback d = (new FairyGUI_PlayCompleteCallback_Event(func)).Call;
            return(d);
        }
        else
        {
            FairyGUI.PlayCompleteCallback d = (new FairyGUI_PlayCompleteCallback_Event(func, self)).CallWithSelf;
            return(d);
        }
    }
Example #8
0
    public static Delegate FairyGUI_PlayCompleteCallback(LuaFunction func, LuaTable self, bool flag)
    {
        if (func == null)
        {
            FairyGUI.PlayCompleteCallback fn = delegate() { };
            return(fn);
        }

        if (!flag)
        {
            FairyGUI_PlayCompleteCallback_Event target = new FairyGUI_PlayCompleteCallback_Event(func);
            FairyGUI.PlayCompleteCallback       d      = target.Call;
            target.method = d.Method;
            return(d);
        }
        else
        {
            FairyGUI_PlayCompleteCallback_Event target = new FairyGUI_PlayCompleteCallback_Event(func, self);
            FairyGUI.PlayCompleteCallback       d      = target.CallWithSelf;
            target.method = d.Method;
            return(d);
        }
    }
    static int Play(IntPtr L)
    {
        try
        {
            int count = LuaDLL.lua_gettop(L);

            if (count == 1 && TypeChecker.CheckTypes(L, 1, typeof(FairyGUI.Transition)))
            {
                FairyGUI.Transition obj = (FairyGUI.Transition)ToLua.ToObject(L, 1);
                obj.Play();
                return(0);
            }
            else if (count == 2 && TypeChecker.CheckTypes(L, 1, typeof(FairyGUI.Transition), typeof(FairyGUI.PlayCompleteCallback)))
            {
                FairyGUI.Transition           obj  = (FairyGUI.Transition)ToLua.ToObject(L, 1);
                FairyGUI.PlayCompleteCallback arg0 = null;
                LuaTypes funcType2 = LuaDLL.lua_type(L, 2);

                if (funcType2 != LuaTypes.LUA_TFUNCTION)
                {
                    arg0 = (FairyGUI.PlayCompleteCallback)ToLua.ToObject(L, 2);
                }
                else
                {
                    LuaFunction func = ToLua.ToLuaFunction(L, 2);
                    arg0 = DelegateFactory.CreateDelegate(typeof(FairyGUI.PlayCompleteCallback), func) as FairyGUI.PlayCompleteCallback;
                }

                obj.Play(arg0);
                return(0);
            }
            else if (count == 4 && TypeChecker.CheckTypes(L, 1, typeof(FairyGUI.Transition), typeof(int), typeof(float), typeof(FairyGUI.PlayCompleteCallback)))
            {
                FairyGUI.Transition obj = (FairyGUI.Transition)ToLua.ToObject(L, 1);
                int   arg0 = (int)LuaDLL.lua_tonumber(L, 2);
                float arg1 = (float)LuaDLL.lua_tonumber(L, 3);
                FairyGUI.PlayCompleteCallback arg2 = null;
                LuaTypes funcType4 = LuaDLL.lua_type(L, 4);

                if (funcType4 != LuaTypes.LUA_TFUNCTION)
                {
                    arg2 = (FairyGUI.PlayCompleteCallback)ToLua.ToObject(L, 4);
                }
                else
                {
                    LuaFunction func = ToLua.ToLuaFunction(L, 4);
                    arg2 = DelegateFactory.CreateDelegate(typeof(FairyGUI.PlayCompleteCallback), func) as FairyGUI.PlayCompleteCallback;
                }

                obj.Play(arg0, arg1, arg2);
                return(0);
            }
            else
            {
                return(LuaDLL.luaL_throw(L, "invalid arguments to method: FairyGUI.Transition.Play"));
            }
        }
        catch (Exception e)
        {
            return(LuaDLL.toluaL_exception(L, e));
        }
    }