自学教程：C++ toluafix_pushusertype_ccobject函数代码示例

int LuaEngine::handleTableViewEvent(ScriptHandlerMgr::HandlerType handlerType,void* data, int numResults, const std::function<void(lua_State*,int)>& func){    if (nullptr == data || numResults <= 0)        return 0;        BasicScriptData* eventData = static_cast<BasicScriptData*>(data);    if (nullptr == eventData->nativeObject || nullptr == eventData->value)        return 0;        LuaTableViewEventData* tableViewData = static_cast<LuaTableViewEventData*>(eventData->value);    int handler = ScriptHandlerMgr::getInstance()->getObjectHandler((void*)eventData->nativeObject, handlerType);        if (0 == handler)        return 0;        Ref* obj = static_cast<Ref*>(eventData->nativeObject);    if (nullptr == obj)        return 0;        int ret = 0;    switch (handlerType)    {        case ScriptHandlerMgr::HandlerType::TABLECELL_SIZE_FOR_INDEX:        {            toluafix_pushusertype_ccobject(_stack->getLuaState(), obj->_ID, &(obj->_luaID), (void*)(obj),"cc.TableView");            _stack->pushLong(*((ssize_t*)tableViewData->value));            ret = _stack->executeFunction(handler, 2, 2, func);        }            break;        case ScriptHandlerMgr::HandlerType::TABLECELL_AT_INDEX:        {            toluafix_pushusertype_ccobject(_stack->getLuaState(), obj->_ID, &(obj->_luaID), (void*)(obj),"cc.TableView");            _stack->pushLong(*((ssize_t*)tableViewData->value));            ret = _stack->executeFunction(handler, 2, 1, func);        }            break;        case ScriptHandlerMgr::HandlerType::TABLEVIEW_NUMS_OF_CELLS:        {            toluafix_pushusertype_ccobject(_stack->getLuaState(), obj->_ID, &(obj->_luaID), (void*)(obj),"cc.TableView");            ret = _stack->executeFunction(handler, 1, 1, func);        }            break;        default:            break;    }        return ret;}

static int lua_cocos2dx_Extension_EventListenerAssetsManagerEx_create(lua_State* L){    if (nullptr == L)        return 0;        int argc = 0;    #if COCOS2D_DEBUG >= 1    tolua_Error tolua_err;    if (!tolua_isusertable(L,1,"cc.EventListenerAssetsManagerEx",0,&tolua_err)) goto tolua_lerror;#endif        argc = lua_gettop(L)-1;        if (argc == 2)    {        #if COCOS2D_DEBUG >= 1        if (!tolua_isusertype(L, 2, "cc.AssetsManagerEx", 0, &tolua_err) ||            !toluafix_isfunction(L,3,"LUA_FUNCTION",0,&tolua_err))            goto tolua_lerror;#endif        cocos2d::extension::AssetsManagerEx* assetManager =  static_cast<cocos2d::extension::AssetsManagerEx*>(tolua_tousertype(L,2,nullptr));                LUA_FUNCTION handler = toluafix_ref_function(L,3,0);                cocos2d::extension::EventListenerAssetsManagerEx* ret = cocos2d::extension::EventListenerAssetsManagerEx::create(assetManager, [=](EventAssetsManagerEx* event){            int id = event? (int)event->_ID : -1;            int* luaID = event? &event->_luaID : nullptr;            toluafix_pushusertype_ccobject(L, id, luaID, (void*)event,"cc.EventAssetsManagerEx");            LuaEngine::getInstance()->getLuaStack()->executeFunctionByHandler(handler, 1);        });                int  id = (ret) ? (int)ret->_ID : -1;        int* luaID = (ret) ? &ret->_luaID : nullptr;        toluafix_pushusertype_ccobject(L, id, luaID, (void*)ret,"cc.EventListenerAssetsManagerEx");        return 1;    }        luaL_error(L, "%s has wrong number of arguments: %d, was expecting %d /n", "create",argc, 2);    return 0;    #if COCOS2D_DEBUG >= 1tolua_lerror:    tolua_error(L,"#ferror in function 'lua_cocos2dx_Extension_EventListenerAssetsManagerEx_create'.",&tolua_err);    return 0;#endif}

int LuaEngine::handleEvenCustom(void* data){    if (nullptr == data)        return 0;        BasicScriptData * basicData = static_cast<BasicScriptData*>(data);    if (NULL == basicData->nativeObject || nullptr == basicData->value )        return 0;        EventCustom* eventCustom = static_cast<EventCustom*>(basicData->value);    int handler = ScriptHandlerMgr::getInstance()->getObjectHandler((void*)basicData->nativeObject, ScriptHandlerMgr::HandlerType::EVENT_CUSTIOM);        if (0 == handler)        return 0;        lua_State* L = _stack->getLuaState();    toluafix_pushusertype_ccobject(L, eventCustom->_ID, &(eventCustom->_luaID), (void*)(eventCustom),"cc.EventCustom");        const std::string &eventName = eventCustom->getEventName();    const void *userData = eventCustom->getUserData();    int ret = 0;    if (eventName.compare(AnimationFrameDisplayedNotification) == 0) {        AnimationFrame::DisplayedEventInfo *eventInfo = (AnimationFrame::DisplayedEventInfo *)userData;        _stack->pushObject(eventInfo->target, "cc.Node");        ccvaluemap_to_luaval(_stack->getLuaState(), *(eventInfo->userInfo));                ret = _stack->executeFunctionByHandler(handler, 3);    } else {        ret = _stack->executeFunctionByHandler(handler, 1);    }    _stack->clean();        return ret;}

 int LuaEngineEx::handleCheckedButtonEvent(cocos2d::ScriptHandlerMgr::HandlerType type, void *data) {     if (!data) {         return 0;     }          BasicScriptData *eventData = static_cast<BasicScriptData*>(data);     if (!eventData->nativeObject) {         return 0;     }          LuaCheckedButtonEventData *checkedBtnData = static_cast<LuaCheckedButtonEventData*>(eventData->value);     int handler = ScriptHandlerMgr::getInstance()->getObjectHandler((void*)eventData->nativeObject, type);          if (!handler) {         return 0;     }          Ref *pObj = static_cast<Ref*>(eventData->nativeObject);          if (!pObj) {         return 0;     }          int ret = 0;     toluafix_pushusertype_ccobject(this->getLuaStack()->getLuaState(), pObj->_ID, &(pObj->_luaID), (void*)pObj, "pf.CheckedButton");     ret = this->getLuaStack()->executeFunctionByHandler(handler, 1);          return ret; }

static int tolua_cocos2dx_BYGraySprite_luabinding_BYGraySprite_create00(lua_State* tolua_S){#ifndef TOLUA_RELEASE tolua_Error tolua_err; if (     !tolua_isusertable(tolua_S,1,"BYGraySprite",0,&tolua_err) ||     !tolua_isstring(tolua_S,2,0,&tolua_err) ||     !tolua_isnoobj(tolua_S,3,&tolua_err) )  goto tolua_lerror; else#endif {  const char* pszFileName = ((const char*)  tolua_tostring(tolua_S,2,0));  {   BYGraySprite* tolua_ret = (BYGraySprite*)  BYGraySprite::create(pszFileName);    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;    toluafix_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"BYGraySprite");  } } return 1;#ifndef TOLUA_RELEASE tolua_lerror: tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err); return 0;#endif}

int lua_cocos2dx_NetScoket_NetUtil_constructor(lua_State* tolua_S){    int argc = 0;    NetUtil* cobj = nullptr;    bool ok  = true;#if COCOS2D_DEBUG >= 1    tolua_Error tolua_err;#endif    argc = lua_gettop(tolua_S)-1;    if (argc == 0)     {        if(!ok)            return 0;        cobj = new NetUtil();        cobj->autorelease();        int ID =  (int)cobj->_ID ;        int* luaID =  &cobj->_luaID ;        toluafix_pushusertype_ccobject(tolua_S, ID, luaID, (void*)cobj,"NetUtil");        return 1;    }    CCLOG("%s has wrong number of arguments: %d, was expecting %d /n", "NetUtil",argc, 0);    return 0;#if COCOS2D_DEBUG >= 1    tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_NetScoket_NetUtil_constructor'.",&tolua_err);#endif    return 0;}

static int tolua_Cocos2d_CCTableViewCell_new(lua_State* tolua_S){#ifndef TOLUA_RELEASE    tolua_Error tolua_err;    if (        !tolua_isusertable(tolua_S,1,"CCTableViewCell",0,&tolua_err) ||        !tolua_isnoobj(tolua_S,2,&tolua_err)        )        goto tolua_lerror;    else#endif    {        CCTableViewCell* tolua_ret = new CCTableViewCell();        if (NULL == tolua_ret)            return 0;                    tolua_ret->autorelease();        int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;        int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;        toluafix_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCTableViewCell");    }    return 1;#ifndef TOLUA_RELEASEtolua_lerror:    tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);    return 0;#endif}

static int tolua_extensions_CCPhysicsSprite_createWithTexture01(lua_State* tolua_S){ tolua_Error tolua_err; if (     !tolua_isusertable(tolua_S,1,"CCPhysicsSprite",0,&tolua_err) ||     !tolua_isusertype(tolua_S,2,"CCTexture2D",0,&tolua_err) ||     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"CCRect",0,&tolua_err)) ||     !tolua_isnoobj(tolua_S,4,&tolua_err) )  goto tolua_lerror; else {  CCTexture2D* pTexture = ((CCTexture2D*)  tolua_tousertype(tolua_S,2,0));  CCRect rect = *((CCRect*)  tolua_tousertype(tolua_S,3,0));  {   CCPhysicsSprite* tolua_ret = (CCPhysicsSprite*)  CCPhysicsSprite::createWithTexture(pTexture,rect);    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;    toluafix_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCPhysicsSprite");  } } return 1;tolua_lerror: return tolua_extensions_CCPhysicsSprite_createWithTexture00(tolua_S);}

static int tolua_extensions_CCPhysicsSprite_createWithSpriteFrame00(lua_State* tolua_S){#ifndef TOLUA_RELEASE tolua_Error tolua_err; if (     !tolua_isusertable(tolua_S,1,"CCPhysicsSprite",0,&tolua_err) ||     !tolua_isusertype(tolua_S,2,"CCSpriteFrame",0,&tolua_err) ||     !tolua_isnoobj(tolua_S,3,&tolua_err) )  goto tolua_lerror; else#endif {  CCSpriteFrame* pSpriteFrame = ((CCSpriteFrame*)  tolua_tousertype(tolua_S,2,0));  {   CCPhysicsSprite* tolua_ret = (CCPhysicsSprite*)  CCPhysicsSprite::createWithSpriteFrame(pSpriteFrame);    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;    toluafix_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCPhysicsSprite");  } } return 1;#ifndef TOLUA_RELEASE tolua_lerror: tolua_error(tolua_S,"#ferror in function 'createWithSpriteFrame'.",&tolua_err); return 0;#endif}

static int tolua_extensions_CCPhysicsSprite_create00(lua_State* tolua_S){#ifndef TOLUA_RELEASE tolua_Error tolua_err; if (     !tolua_isusertable(tolua_S,1,"CCPhysicsSprite",0,&tolua_err) ||     !tolua_isstring(tolua_S,2,0,&tolua_err) ||     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"CCRect",0,&tolua_err)) ||     !tolua_isnoobj(tolua_S,4,&tolua_err) )  goto tolua_lerror; else#endif {  const char* pszFileName = ((const char*)  tolua_tostring(tolua_S,2,0));  CCRect rect = *((CCRect*)  tolua_tousertype(tolua_S,3,0));  {   CCPhysicsSprite* tolua_ret = (CCPhysicsSprite*)  CCPhysicsSprite::create(pszFileName,rect);    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;    toluafix_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCPhysicsSprite");  } } return 1;#ifndef TOLUA_RELEASE tolua_lerror: tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err); return 0;#endif}

int LuaEngine::handleEventAcc(void* data){    if (nullptr == data)        return 0;        BasicScriptData* basicScriptData = static_cast<BasicScriptData*>(data);    if (nullptr == basicScriptData->nativeObject || nullptr == basicScriptData->value)        return 0;        int handler = ScriptHandlerMgr::getInstance()->getObjectHandler(basicScriptData->nativeObject, ScriptHandlerMgr::HandlerType::EVENT_ACC);    if (0 == handler)        return 0;        lua_State* L = _stack->getLuaState();        LuaEventAccelerationData* eventListennerAcc = static_cast<LuaEventAccelerationData*>(basicScriptData->value);        toluafix_pushusertype_ccobject(L, eventListennerAcc->event->_ID, &(eventListennerAcc->event->_luaID), (void*)(eventListennerAcc->event),"cc.Event");    Acceleration*  accleration = static_cast<Acceleration*>(eventListennerAcc->acc);    lua_pushnumber(L,accleration->x);    lua_pushnumber(L,accleration->y);    lua_pushnumber(L,accleration->z);    lua_pushnumber(L,accleration->timestamp);    int ret = _stack->executeFunctionByHandler(handler, 5);    _stack->clean();    return ret;}

static int tolua_cocos2d_CCBProxy_create(lua_State* tolua_S){    if (NULL == tolua_S)        return 0;        int argc = 0;    #if COCOS2D_DEBUG >= 1	tolua_Error tolua_err;	if (!tolua_isusertable(tolua_S,1,"cc.CCBProxy",0,&tolua_err)) goto tolua_lerror;#endif        argc = lua_gettop(tolua_S) - 1;        if (0 == argc)    {        CCBProxy* tolua_ret = (CCBProxy*)CCBProxy::create();                int  nID = (tolua_ret) ? (int)tolua_ret->_ID : -1;        int *pLuaID = (tolua_ret) ? &tolua_ret->_luaID : NULL;        toluafix_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"cc.CCBProxy");        return 1;    }        CCLOG("%s function of CCBProxy has wrong number of arguments: %d, was expecting %d/n", "cc.CCBProxy:create", argc, 0);    return 0;    #if COCOS2D_DEBUG >= 1tolua_lerror:    tolua_error(tolua_S,"#ferror in function 'tolua_cocos2d_CCBProxy_create'.",&tolua_err);    return 0;#endif}

static int tolua_cocos2d_CCBProxy_readCCBFromFile(lua_State* tolua_S){    if (NULL == tolua_S)        return 0;        int argc = 0;    CCBProxy* self = nullptr;    const char* ccbFilePath = nullptr;    CCBReader*  ccbReader   = nullptr;    bool        setOwner    = false;    Node*       tolua_ret    = nullptr;    int         ID          = 0;    int*        luaID       = nullptr;        #if COCOS2D_DEBUG >= 1    tolua_Error tolua_err;	if (!tolua_isusertype(tolua_S,1,"cc.CCBProxy",0,&tolua_err)) goto tolua_lerror;#endif        self = static_cast<CCBProxy*>(tolua_tousertype(tolua_S,1,0));    #if COCOS2D_DEBUG >= 1	if (nullptr == self) {		tolua_error(tolua_S,"invalid 'self' in function 'tolua_cocos2d_CCBProxy_readCCBFromFile'/n", NULL);		return 0;	}#endif        argc = lua_gettop(tolua_S) - 1;        if (2 == argc || 3 == argc)    {#if COCOS2D_DEBUG >= 1        if (!tolua_isstring(tolua_S, 2, 0, &tolua_err)||            !tolua_isusertype(tolua_S,3,"cc.CCBReader",0,&tolua_err)||            !tolua_isboolean(tolua_S,4,1,&tolua_err )            )            goto tolua_lerror;#endif        ccbFilePath = ((const char*)  tolua_tostring(tolua_S,2,0));        ccbReader   = ((CCBReader*)  tolua_tousertype(tolua_S,3,0));        setOwner = (bool)  tolua_toboolean(tolua_S,4,-1);        tolua_ret = (Node*) self->readCCBFromFile(ccbFilePath, ccbReader, setOwner);        ID = (tolua_ret) ? (int)tolua_ret->_ID : -1;        luaID = (tolua_ret) ? &tolua_ret->_luaID : NULL;        toluafix_pushusertype_ccobject(tolua_S, ID, luaID, (void*)tolua_ret,"cc.Node");        return 1;    }        CCLOG("%s function of CCBProxy  has wrong number of arguments: %d, was expecting %d/n", "cc.CCBReader:readCCBFromFile", argc, 2);    return 0;    #if COCOS2D_DEBUG >= 1tolua_lerror:    tolua_error(tolua_S,"#ferror in function 'tolua_cocos2d_CCBProxy_readCCBFromFile'.",&tolua_err);    return 0;#endif}

int lua_cocos2dx_physics_PhysicsWorld_getScene(lua_State* tolua_S){    int argc = 0;    cocos2d::PhysicsWorld* cobj = nullptr;    bool ok  = true;    #if COCOS2D_DEBUG >= 1    tolua_Error tolua_err;#endif    #if COCOS2D_DEBUG >= 1    if (!tolua_isusertype(tolua_S,1,"cc.PhysicsWorld",0,&tolua_err)) goto tolua_lerror;#endif        cobj = (cocos2d::PhysicsWorld*)tolua_tousertype(tolua_S,1,0);    #if COCOS2D_DEBUG >= 1    if (!cobj)    {        tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_physics_PhysicsWorld_getScene'", NULL);        return 0;    }#endif        argc = lua_gettop(tolua_S)-1;    if (argc == 0)    {        if(!ok)            return 0;        cocos2d::Scene& ret = cobj->getScene();        do {                        std::string hashName = typeid(ret).name();            auto iter = g_luaType.find(hashName);            std::string className = "";            if(iter != g_luaType.end()){                className = iter->second.c_str();            } else {                className = "cc.Scene";            }                        int ID =  (int)(ret._ID);            int* luaID = &(ret._luaID);            toluafix_pushusertype_ccobject(tolua_S,ID, luaID, (void*)(&ret),className.c_str());                    }while (0);        return 1;    }    CCLOG("%s has wrong number of arguments: %d, was expecting %d /n", "getScene",argc, 0);    return 0;    #if COCOS2D_DEBUG >= 1tolua_lerror:    tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_physics_PhysicsWorld_getScene'.",&tolua_err);#endif        return 0;}

int lua_cocos2dx_physics_PhysicsWorld_queryPoint(lua_State* tolua_S){    int argc = 0;    cocos2d::PhysicsWorld* cobj = nullptr;    bool ok  = true;    #if COCOS2D_DEBUG >= 1    tolua_Error tolua_err;#endif    #if COCOS2D_DEBUG >= 1    if (!tolua_isusertype(tolua_S,1,"cc.PhysicsWorld",0,&tolua_err)) goto tolua_lerror;#endif        cobj = (cocos2d::PhysicsWorld*)tolua_tousertype(tolua_S,1,0);    #if COCOS2D_DEBUG >= 1    if (!cobj)    {        tolua_error(tolua_S,"invalid 'cobj' in function 'lua_cocos2dx_physics_PhysicsWorld_queryPoint'", NULL);        return 0;    }#endif        argc = lua_gettop(tolua_S)-1;    if (argc == 2)    {        std::function<bool (cocos2d::PhysicsWorld &, cocos2d::PhysicsShape &, void *)> arg0;        cocos2d::Point arg1;        LUA_FUNCTION handler = toluafix_ref_function(tolua_S, 2, 0);        do {            arg0 = [handler, tolua_S](cocos2d::PhysicsWorld &world, cocos2d::PhysicsShape &shape, void * data) -> bool            {                                tolua_pushusertype(tolua_S, (void*)(&world), getLuaTypeName(&world, "cc.PhysicsWorld"));                toluafix_pushusertype_ccobject(tolua_S, shape._ID, &shape._luaID, (void*)(&shape), "cc.PhysicsShape");                return LuaEngine::getInstance()->getLuaStack()->executeFunctionByHandler(handler, 2);            };            assert(false);        } while(0)            ;        ok &= luaval_to_point(tolua_S, 3, &arg1);        if(!ok)            return 0;        cobj->queryPoint(arg0, arg1, nullptr);        toluafix_remove_function_by_refid(tolua_S, handler);        return 0;    }    CCLOG("%s has wrong number of arguments: %d, was expecting %d /n", "queryPoint",argc, 3);    return 0;    #if COCOS2D_DEBUG >= 1tolua_lerror:    tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_physics_PhysicsWorld_queryPoint'.",&tolua_err);#endif        return 0;}

int tolua_new_Scheduler(lua_State *L){    cocos2d::Scheduler *obj = new cocos2d::Scheduler();    cocos2d::Director::getInstance()->getScheduler()        ->scheduleUpdate(obj, 1, false);    if (obj) {        toluafix_pushusertype_ccobject(L,            (int)obj->_ID, &obj->_luaID, (void *)obj, "cc.Scheduler");    }    return 1;}

static int lua_cocos2dx_experimental_WebView_setOnShouldStartLoading(lua_State* L){        int argc = 0;    cocos2d::experimental::ui::WebView* self = nullptr;    #if COCOS2D_DEBUG >= 1    tolua_Error tolua_err;    if (!tolua_isusertype(L,1,"ccexp.WebView",0,&tolua_err)) goto tolua_lerror;#endif        self = static_cast<cocos2d::experimental::ui::WebView*>(tolua_tousertype(L,1,0));    #if COCOS2D_DEBUG >= 1	if (nullptr == self) {		tolua_error(L,"invalid 'self' in function 'lua_cocos2dx_experimental_WebView_setOnShouldStartLoading'/n", nullptr);		return 0;	}#endif    argc = lua_gettop(L) - 1;    if (argc == 1)    {#if COCOS2D_DEBUG >= 1        if (!toluafix_isfunction(L,2,"LUA_FUNCTION",0,&tolua_err))        {            goto tolua_lerror;        }#endif                LUA_FUNCTION handler = (  toluafix_ref_function(L,2,0));        std::function<bool(experimental::ui::WebView *sender, const std::string &url)> callback = [L,handler](experimental::ui::WebView *sender, const std::string &url)->bool{            toluafix_pushusertype_ccobject(L, sender->_ID, &(sender->_luaID), (void*)sender,"ccexp.WebView");            tolua_pushcppstring(L, url);            return LuaEngine::getInstance()->getLuaStack()->executeFunctionByHandler(handler, 2);        };                ScriptHandlerMgr::getInstance()->addCustomHandler((void*)self, handler);        self->setOnShouldStartLoading(callback);                return 0;    }    luaL_error(L, "%s has wrong number of arguments: %d, was expecting %d/n ", "ccexp.WebView:setOnShouldStartLoading",argc, 1);    return 0;#if COCOS2D_DEBUG >= 1    tolua_lerror:    tolua_error(L, "#ferror in function 'lua_cocos2dx_experimental_WebView_setOnShouldStartLoading'.", &tolua_err);#endif    return 0;}

static int tolua_cocos2dx_EventListenerController_clone(lua_State* tolua_S){    if (nullptr == tolua_S)        return 0;        int argc = 0;    cocos2d::EventListenerController* self = nullptr;#if COCOS2D_DEBUG >= 1    tolua_Error tolua_err;    if (!tolua_isusertype(tolua_S, 1, "cc.EventListenerController", 0, &tolua_err))  goto tolua_lerror;#endif        self = static_cast<cocos2d::EventListenerController*>(tolua_tousertype(tolua_S,1,0));#if COCOS2D_DEBUG >= 1    if (nullptr == self) {		tolua_error(tolua_S,"invalid 'self' in function 'tolua_cocos2dx_EventListenerController_clone'/n", nullptr);		return 0;	}#endif        argc = lua_gettop(tolua_S) - 1;        if (argc == 0)    {        cocos2d::EventListenerController* tolua_ret = cocos2d::EventListenerController::create();        if(nullptr == tolua_ret)            return 0;                cloneEventListenerControllerHandler(self, tolua_ret, ScriptHandlerMgr::HandlerType::EVENT_CONTROLLER_CONNECTED);        cloneEventListenerControllerHandler(self, tolua_ret, ScriptHandlerMgr::HandlerType::EVENT_CONTROLLER_DISCONNECTED);        cloneEventListenerControllerHandler(self, tolua_ret, ScriptHandlerMgr::HandlerType::EVENT_CONTROLLER_KEYDOWN);        cloneEventListenerControllerHandler(self, tolua_ret, ScriptHandlerMgr::HandlerType::EVENT_CONTROLLER_KEYUP);        cloneEventListenerControllerHandler(self, tolua_ret, ScriptHandlerMgr::HandlerType::EVENT_CONTROLLER_KEYREPEAT);        cloneEventListenerControllerHandler(self, tolua_ret, ScriptHandlerMgr::HandlerType::EVENT_CONTROLLER_AXIS);                int ID = (tolua_ret) ? (int)tolua_ret->_ID : -1;        int* luaID = (tolua_ret) ? &tolua_ret->_luaID : NULL;        toluafix_pushusertype_ccobject(tolua_S, ID, luaID, (void*)tolua_ret,"cc.EventListenerController");                return 1;    }        CCLOG("'clone' has wrong number of arguments: %d, was expecting %d/n", argc, 0);    return 0;    #if COCOS2D_DEBUG >= 1tolua_lerror:    tolua_error(tolua_S,"#ferror in function 'clone'.",&tolua_err);    return 0;#endif}

static int tolua_Cocos2dx_CCTableView_create00(lua_State* tolua_S){    #ifndef TOLUA_RELEASE    tolua_Error tolua_err;    if (        !tolua_isusertable(tolua_S, 1, "CCTableView", 0, &tolua_err) ||        !tolua_isusertype(tolua_S, 2, "CCSize", 0, &tolua_err)       ||        !tolua_isnoobj(tolua_S,3,&tolua_err)        )        goto tolua_lerror;    else#endif    {        LUA_TableViewDataSource* dataSource = new LUA_TableViewDataSource();        if (NULL == dataSource)            return 0;                CCSize size = *((CCSize*)  tolua_tousertype(tolua_S,2,0));        CCTableView* tolua_ret = CCTableView::create(dataSource, size);        if (NULL == tolua_ret)            return 0;                tolua_ret->reloadData();                CCDictionary* userDict = new CCDictionary();        userDict->setObject(dataSource, KEY_TABLEVIEW_DATA_SOURCE);        tolua_ret->setUserObject(userDict);        userDict->release();                dataSource->release();                int  nID = (int)tolua_ret->m_uID;        int* pLuaID =  &tolua_ret->m_nLuaID;        toluafix_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCTableView");                return 1;    }    return 0;#ifndef TOLUA_RELEASEtolua_lerror:    tolua_error(tolua_S,"#ferror in function 'create'.",&tolua_err);    return 0;#endif}

static int tolua_cocos2d_CCBProxy_createCCBReader(lua_State* tolua_S){    if (NULL == tolua_S)        return 0;        int argc = 0;    CCBProxy* self = nullptr;    #if COCOS2D_DEBUG >= 1    tolua_Error tolua_err;	if (!tolua_isusertype(tolua_S,1,"cc.CCBProxy",0,&tolua_err)) goto tolua_lerror;#endif        self = static_cast<CCBProxy*>(tolua_tousertype(tolua_S,1,0));    #if COCOS2D_DEBUG >= 1	if (nullptr == self) {		tolua_error(tolua_S,"invalid 'self' in function 'tolua_cocos2d_CCBProxy_createCCBReader'/n", NULL);		return 0;	}#endif        argc = lua_gettop(tolua_S) - 1;        if (0 == argc)    {        CCBReader* tolua_ret = (CCBReader*) self->createCCBReader();        int nID = (tolua_ret) ? (int)tolua_ret->_ID : -1;        int* pLuaID = (tolua_ret) ? &tolua_ret->_luaID : NULL;        toluafix_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"cc.CCBReader");        return 1;    }        CCLOG("%s function of CCBProxy  has wrong number of arguments: %d, was expecting %d/n", "cc.CCBProxy:createCCBReader", argc, 0);    return 0;    #if COCOS2D_DEBUG >= 1tolua_lerror:    tolua_error(tolua_S,"#ferror in function 'tolua_cocos2d_CCBProxy_createCCBReader'.",&tolua_err);    return 0;#endif}

static int tolua_Cocos2dx_CCTableView_create01(lua_State* tolua_S){    tolua_Error tolua_err;    if (        !tolua_isusertable(tolua_S,1,"CCTableView",0,&tolua_err) ||        !tolua_isusertype(tolua_S, 2, "CCSize", 0, &tolua_err)   ||        !tolua_isusertype(tolua_S,3,"CCNode",0,&tolua_err)       ||        !tolua_isnoobj(tolua_S,4,&tolua_err)        )        goto tolua_lerror;    else    {                LUA_TableViewDataSource* dataSource = new LUA_TableViewDataSource();        if (NULL == dataSource)            return 0;                CCSize size = *((CCSize*)  tolua_tousertype(tolua_S,2,0));        CCNode* node = static_cast<CCNode*>(tolua_tousertype(tolua_S, 3, 0));        CCTableView* tolua_ret = CCTableView::create(dataSource,size,node);        if (NULL == tolua_ret)            return 0;                tolua_ret->reloadData();                CCDictionary* userDict = new CCDictionary();        userDict->setObject(dataSource, KEY_TABLEVIEW_DATA_SOURCE);        tolua_ret->setUserObject(userDict);        userDict->release();                dataSource->release();                        int  nID = (int)tolua_ret->m_uID;        int* pLuaID =  &tolua_ret->m_nLuaID;        toluafix_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCTableView");        return 1;    }    return 0;tolua_lerror:    return tolua_Cocos2dx_CCTableView_create00(tolua_S);}

static int tolua_extensions_CCPhysicsSprite_create02(lua_State* tolua_S){ tolua_Error tolua_err; if (     !tolua_isusertable(tolua_S,1,"CCPhysicsSprite",0,&tolua_err) ||     !tolua_isnoobj(tolua_S,2,&tolua_err) )  goto tolua_lerror; else {  {   CCPhysicsSprite* tolua_ret = (CCPhysicsSprite*)  CCPhysicsSprite::create();    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;    toluafix_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCPhysicsSprite");  } } return 1;tolua_lerror: return tolua_extensions_CCPhysicsSprite_create01(tolua_S);}

int LuaEngine::handleEventKeyboard(ScriptHandlerMgr::HandlerType type, void* data){    if (nullptr == data)        return 0;        BasicScriptData* basicScriptData = static_cast<BasicScriptData*>(data);    if (nullptr == basicScriptData->nativeObject || nullptr == basicScriptData->value)        return 0;        LuaEventKeyboarData* keyboardData = static_cast<LuaEventKeyboarData*>(basicScriptData->value);        int handler = ScriptHandlerMgr::getInstance()->getObjectHandler(basicScriptData->nativeObject, type);    if (0 == handler)        return 0;        lua_State* L = _stack->getLuaState();    lua_pushinteger(L, keyboardData->keyCode);    toluafix_pushusertype_ccobject(L, keyboardData->event->_ID, &(keyboardData->event->_luaID), (void*)(keyboardData->event),"cc.Event");    int ret = _stack->executeFunctionByHandler(handler, 2);    _stack->clean();    return ret;}

static int tolua_extensions_CCPhysicsSprite_create01(lua_State* tolua_S){ tolua_Error tolua_err; if (     !tolua_isusertable(tolua_S,1,"CCPhysicsSprite",0,&tolua_err) ||     !tolua_isstring(tolua_S,2,0,&tolua_err) ||     !tolua_isnoobj(tolua_S,3,&tolua_err) )  goto tolua_lerror; else {  const char* pszFileName = ((const char*)  tolua_tostring(tolua_S,2,0));  {   CCPhysicsSprite* tolua_ret = (CCPhysicsSprite*)  CCPhysicsSprite::create(pszFileName);    int nID = (tolua_ret) ? (int)tolua_ret->m_uID : -1;    int* pLuaID = (tolua_ret) ? &tolua_ret->m_nLuaID : NULL;    toluafix_pushusertype_ccobject(tolua_S, nID, pLuaID, (void*)tolua_ret,"CCPhysicsSprite");  } } return 1;tolua_lerror: return tolua_extensions_CCPhysicsSprite_create00(tolua_S);}

int lua_cocos2dx_experimental_webview_WebView_constructor(lua_State* tolua_S){    int argc = 0;    cocos2d::experimental::ui::WebView* cobj = nullptr;    bool ok  = true;#if COCOS2D_DEBUG >= 1    tolua_Error tolua_err;#endif    argc = lua_gettop(tolua_S)-1;    if (argc == 0)     {        if(!ok)        {            tolua_error(tolua_S,"invalid arguments in function 'lua_cocos2dx_experimental_webview_WebView_constructor'", nullptr);            return 0;        }        cobj = new cocos2d::experimental::ui::WebView();        cobj->autorelease();        int ID =  (int)cobj->_ID ;        int* luaID =  &cobj->_luaID ;        toluafix_pushusertype_ccobject(tolua_S, ID, luaID, (void*)cobj,"ccexp.WebView");        return 1;    }    luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d /n", "ccexp.WebView:WebView",argc, 0);    return 0;#if COCOS2D_DEBUG >= 1    tolua_error(tolua_S,"#ferror in function 'lua_cocos2dx_experimental_webview_WebView_constructor'.",&tolua_err);#endif    return 0;}

int lua_binarystream_BinaryStream_constructor(lua_State* tolua_S){    int argc = 0;    cocoslua_ext::BinaryStream* cobj = nullptr;    bool ok  = true;#if COCOS2D_DEBUG >= 1    tolua_Error tolua_err;#endif    argc = lua_gettop(tolua_S)-1;    if (argc == 0)     {        if(!ok)        {            tolua_error(tolua_S,"invalid arguments in function 'lua_binarystream_BinaryStream_constructor'", nullptr);            return 0;        }        cobj = new cocoslua_ext::BinaryStream();        cobj->autorelease();        int ID =  (int)cobj->_ID ;        int* luaID =  &cobj->_luaID ;        toluafix_pushusertype_ccobject(tolua_S, ID, luaID, (void*)cobj,"ccluaext.BinaryStream");        return 1;    }    luaL_error(tolua_S, "%s has wrong number of arguments: %d, was expecting %d /n", "ccluaext.BinaryStream:BinaryStream",argc, 0);    return 0;#if COCOS2D_DEBUG >= 1    tolua_error(tolua_S,"#ferror in function 'lua_binarystream_BinaryStream_constructor'.",&tolua_err);#endif    return 0;}

void LuaStack::pushObject(Object* objectValue, const char* typeName){    toluafix_pushusertype_ccobject(_state, objectValue->_ID, &objectValue->_luaID, objectValue, typeName);}

int CCLuaEngine::pushCCObjectToLuaStack(CCObject* pObject, const char* typeName){    toluafix_pushusertype_ccobject(m_state, pObject->m_uID, &pObject->m_nLuaID, pObject, typeName);    return lua_gettop(m_state);}