Lua_extensions_CCB.cpp

/scripting/lua/cocos2dx_support/Lua_extensions_CCB.cpp

https://bitbucket.org/gontamoteam/gontamo-repo · C++ · 1519 lines · 1421 code · 51 blank · 47 comment · 84 complexity · acd20ebec8324dc03985384a37654c13 MD5 · raw file

#ifdef __cplusplus
extern "C" {
#endif
    #include "tolua_fix.h"
#ifdef __cplusplus
}
#endif

#include <map>
#include <string>
#include "Lua_extensions_CCB.h"
#include "cocos2d.h"
#include "cocos-ext.h"
#include "CCBProxy.h"

using namespace cocos2d;
using namespace cocos2d::extension;

#ifdef __cplusplus
static int tolua_collect_CCBAnimationManager (lua_State* tolua_S)
{
    CCBAnimationManager* self = (CCBAnimationManager*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CCBReader (lua_State* tolua_S)
{
    CCBReader* self = (CCBReader*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}

static int tolua_collect_CCBProxy (lua_State* tolua_S)
{
    CCBProxy *self = (CCBProxy*) tolua_tousertype(tolua_S,1,0);
    Mtolua_delete(self);
    return 0;
}
#endif
/* function to release collected object via destructor */
static void tolua_reg_extensions_ccb_type(lua_State* tolua_S)
{
    tolua_usertype(tolua_S, "CCBAnimationManager");
    tolua_usertype(tolua_S, "CCBReader");
    tolua_usertype(tolua_S, "CCBProxy");
}

/* method: delete of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_delete00
static int tolua_Cocos2d_CCBReader_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBReader* self = (CCBReader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
        Mtolua_delete(self);
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_new00
static int tolua_Cocos2d_CCBReader_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertable(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        {
            CCBReader* tolua_ret = (CCBReader*)  Mtolua_new((CCBReader)());
            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,"CCBReader");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_new00_local
static int tolua_Cocos2d_CCBReader_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertable(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        {
            CCBReader* tolua_ret = (CCBReader*)  Mtolua_new((CCBReader)());
            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,"CCBReader");
            tolua_register_gc(tolua_S,lua_gettop(tolua_S));
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOwnerCallbackNames of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_getOwnerCallbackNames00
static int tolua_Cocos2d_CCBReader_getOwnerCallbackNames00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBReader* self = (CCBReader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOwnerCallbackNames'", NULL);
#endif
        {
            CCArray* tolua_ret = (CCArray*)  self->getOwnerCallbackNames();
            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,"CCArray");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getOwnerCallbackNames'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCCBRootPath of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_setCCBRootPath00
static int tolua_Cocos2d_CCBReader_setCCBRootPath00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isstring(tolua_S,2,0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,3,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBReader* self = (CCBReader*)  tolua_tousertype(tolua_S,1,0);
        const char* pCCBRootPath = ((const char*)  tolua_tostring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCCBRootPath'", NULL);
#endif
        {
            self->setCCBRootPath(pCCBRootPath);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'setCCBRootPath'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOwnerCallbackNodes of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_getOwnerCallbackNodes00
static int tolua_Cocos2d_CCBReader_getOwnerCallbackNodes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBReader* self = (CCBReader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOwnerCallbackNodes'", NULL);
#endif
        {
            CCArray* tolua_ret = (CCArray*)  self->getOwnerCallbackNodes();
            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,"CCArray");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getOwnerCallbackNodes'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getCCBRootPath of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_getCCBRootPath00
static int tolua_Cocos2d_CCBReader_getCCBRootPath00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"const CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        const CCBReader* self = (const CCBReader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getCCBRootPath'", NULL);
#endif
        {
            const std::string tolua_ret = (const std::string)  self->getCCBRootPath();
            tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getCCBRootPath'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOwnerOutletNodes of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_getOwnerOutletNodes00
static int tolua_Cocos2d_CCBReader_getOwnerOutletNodes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBReader* self = (CCBReader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOwnerOutletNodes'", NULL);
#endif
        {
            CCArray* tolua_ret = (CCArray*)  self->getOwnerOutletNodes();
            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,"CCArray");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getOwnerOutletNodes'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: readUTF8 of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_readUTF800
static int tolua_Cocos2d_CCBReader_readUTF800(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBReader* self = (CCBReader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'readUTF8'", NULL);
#endif
        {
            std::string tolua_ret = (std::string)  self->readUTF8();
            tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'readUTF8'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOwnerOutletNames of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_getOwnerOutletNames00
static int tolua_Cocos2d_CCBReader_getOwnerOutletNames00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBReader* self = (CCBReader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOwnerOutletNames'", NULL);
#endif
        {
            CCArray* tolua_ret = (CCArray*)  self->getOwnerOutletNames();
            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,"CCArray");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getOwnerOutletNames'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAnimationManagers of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_setAnimationManagers00
static int tolua_Cocos2d_CCBReader_setAnimationManagers00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isusertype(tolua_S,2,"CCDictionary",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,3,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBReader* self = (CCBReader*)  tolua_tousertype(tolua_S,1,0);
        CCDictionary* x = ((CCDictionary*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAnimationManagers'", NULL);
#endif
        {
            self->setAnimationManagers(x);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'setAnimationManagers'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAnimationManagersForNodes of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_getAnimationManagersForNodes00
static int tolua_Cocos2d_CCBReader_getAnimationManagersForNodes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBReader* self = (CCBReader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAnimationManagersForNodes'", NULL);
#endif
        {
            CCArray* tolua_ret = (CCArray*)  self->getAnimationManagersForNodes();
            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,"CCArray");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getAnimationManagersForNodes'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getNodesWithAnimationManagers of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_getNodesWithAnimationManagers00
static int tolua_Cocos2d_CCBReader_getNodesWithAnimationManagers00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBReader* self = (CCBReader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getNodesWithAnimationManagers'", NULL);
#endif
        {
            CCArray* tolua_ret = (CCArray*)  self->getNodesWithAnimationManagers();
            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,"CCArray");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getNodesWithAnimationManagers'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAnimationManager of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_getAnimationManager00
static int tolua_Cocos2d_CCBReader_getAnimationManager00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBReader* self = (CCBReader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAnimationManager'", NULL);
#endif
        {
            CCBAnimationManager* tolua_ret = (CCBAnimationManager*)  self->getAnimationManager();
            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,"CCBAnimationManager");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getAnimationManager'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setResolutionScale of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_setResolutionScale00
static int tolua_Cocos2d_CCBReader_setResolutionScale00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertable(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,3,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        float scale = ((float)  tolua_tonumber(tolua_S,2,0));
        {
            CCBReader::setResolutionScale(scale);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'setResolutionScale'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_new01
static int tolua_Cocos2d_CCBReader_new01(lua_State* tolua_S)
{
    tolua_Error tolua_err;
    if (
        !tolua_isusertable(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
    {
        {
            CCBReader* tolua_ret = (CCBReader*)  Mtolua_new((CCBReader)());
            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,"CCBReader");
        }
    }
    return 1;
tolua_lerror:
    return tolua_Cocos2d_CCBReader_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_new01_local
static int tolua_Cocos2d_CCBReader_new01_local(lua_State* tolua_S)
{
    tolua_Error tolua_err;
    if (
        !tolua_isusertable(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
    {
        {
            CCBReader* tolua_ret = (CCBReader*)  Mtolua_new((CCBReader)());
            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,"CCBReader");
            tolua_register_gc(tolua_S,lua_gettop(tolua_S));
        }
    }
    return 1;
tolua_lerror:
    return tolua_Cocos2d_CCBReader_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getOwner of class  CCBReader */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBReader_getAnimationManager00
static int tolua_Cocos2d_ccbreader_getOwner00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBReader",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBReader* self = (CCBReader*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getOwner'", NULL);
#endif
        {
            CCObject* tolua_ret = (CCObject*)self->getOwner();
            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,"CCObject");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getOwner'.",&tolua_err);
    return 0;
#endif
}
#endif//#ifndef TOLUA_DISABLE

/* method: new of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_new00
static int tolua_Cocos2d_CCBAnimationManager_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertable(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        {
            CCBAnimationManager* tolua_ret = (CCBAnimationManager*)  Mtolua_new((CCBAnimationManager)());
            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,"CCBAnimationManager");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_new00_local
static int tolua_Cocos2d_CCBAnimationManager_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertable(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        {
            CCBAnimationManager* tolua_ret = (CCBAnimationManager*)  Mtolua_new((CCBAnimationManager)());
            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,"CCBAnimationManager");
            tolua_register_gc(tolua_S,lua_gettop(tolua_S));
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_delete00
static int tolua_Cocos2d_CCBAnimationManager_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
        Mtolua_delete(self);
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveAnimationsFromNode of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_moveAnimationsFromNode00
static int tolua_Cocos2d_CCBAnimationManager_moveAnimationsFromNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
        !tolua_isusertype(tolua_S,3,"CCNode",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,4,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
        CCNode* fromNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
        CCNode* toNode = ((CCNode*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveAnimationsFromNode'", NULL);
#endif
        {
            self->moveAnimationsFromNode(fromNode,toNode);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'moveAnimationsFromNode'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAutoPlaySequenceId of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_setAutoPlaySequenceId00
static int tolua_Cocos2d_CCBAnimationManager_setAutoPlaySequenceId00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,3,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
        int autoPlaySequenceId = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAutoPlaySequenceId'", NULL);
#endif
        {
            self->setAutoPlaySequenceId(autoPlaySequenceId);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'setAutoPlaySequenceId'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDocumentCallbackNames of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_getDocumentCallbackNames00
static int tolua_Cocos2d_CCBAnimationManager_getDocumentCallbackNames00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDocumentCallbackNames'", NULL);
#endif
        {
            CCArray* tolua_ret = (CCArray*)  self->getDocumentCallbackNames();
            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,"CCArray");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getDocumentCallbackNames'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBaseValue of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_setBaseValue00
static int tolua_Cocos2d_CCBAnimationManager_setBaseValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isusertype(tolua_S,2,"CCObject",0,&tolua_err) ||
        !tolua_isusertype(tolua_S,3,"CCNode",0,&tolua_err) ||
        !tolua_isstring(tolua_S,4,0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,5,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
        CCObject* pValue = ((CCObject*)  tolua_tousertype(tolua_S,2,0));
        CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,3,0));
        const char* pPropName = ((const char*)  tolua_tostring(tolua_S,4,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBaseValue'", NULL);
#endif
        {
            self->setBaseValue(pValue,pNode,pPropName);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'setBaseValue'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDocumentOutletNodes of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_getDocumentOutletNodes00
static int tolua_Cocos2d_CCBAnimationManager_getDocumentOutletNodes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDocumentOutletNodes'", NULL);
#endif
        {
            CCArray* tolua_ret = (CCArray*)  self->getDocumentOutletNodes();
            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,"CCArray");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getDocumentOutletNodes'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addNode of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_addNode00
static int tolua_Cocos2d_CCBAnimationManager_addNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
        !tolua_isusertype(tolua_S,3,"CCDictionary",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,4,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
        CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
        CCDictionary* pSeq = ((CCDictionary*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addNode'", NULL);
#endif
        {
            self->addNode(pNode,pSeq);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'addNode'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLastCompletedSequenceName of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_getLastCompletedSequenceName00
static int tolua_Cocos2d_CCBAnimationManager_getLastCompletedSequenceName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLastCompletedSequenceName'", NULL);
#endif
        {
            std::string tolua_ret = (std::string)  self->getLastCompletedSequenceName();
            tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getLastCompletedSequenceName'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRootNode of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_setRootNode00
static int tolua_Cocos2d_CCBAnimationManager_setRootNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,3,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
        CCNode* pRootNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRootNode'", NULL);
#endif
        {
            self->setRootNode(pRootNode);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'setRootNode'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addDocumentOutletName of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_addDocumentOutletName00
static int tolua_Cocos2d_CCBAnimationManager_addDocumentOutletName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,3,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
        std::string name = ((std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addDocumentOutletName'", NULL);
#endif
        {
            self->addDocumentOutletName(name);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'addDocumentOutletName'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSequences of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_getSequences00
static int tolua_Cocos2d_CCBAnimationManager_getSequences00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSequences'", NULL);
#endif
        {
            CCArray* tolua_ret = (CCArray*)  self->getSequences();
            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,"CCArray");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getSequences'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRootContainerSize of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_getRootContainerSize00
static int tolua_Cocos2d_CCBAnimationManager_getRootContainerSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRootContainerSize'", NULL);
#endif
        {
            const CCSize& tolua_ret = (const CCSize&)  self->getRootContainerSize();
            tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CCSize");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getRootContainerSize'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setDocumentControllerName of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_setDocumentControllerName00
static int tolua_Cocos2d_CCBAnimationManager_setDocumentControllerName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,3,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
        const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setDocumentControllerName'", NULL);
#endif
        {
            self->setDocumentControllerName(name);
            tolua_pushcppstring(tolua_S,(const char*)name);
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'setDocumentControllerName'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getContainerSize of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_getContainerSize00
static int tolua_Cocos2d_CCBAnimationManager_getContainerSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,3,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
        CCNode* pNode = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getContainerSize'", NULL);
#endif
        {
            const CCSize& tolua_ret = (const CCSize&)  self->getContainerSize(pNode);
            tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const CCSize");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getContainerSize'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getDocumentOutletNames of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_getDocumentOutletNames00
static int tolua_Cocos2d_CCBAnimationManager_getDocumentOutletNames00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getDocumentOutletNames'", NULL);
#endif
        {
            CCArray* tolua_ret = (CCArray*)  self->getDocumentOutletNames();
            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,"CCArray");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getDocumentOutletNames'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: init of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_init00
static int tolua_Cocos2d_CCBAnimationManager_init00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'init'", NULL);
#endif
        {
            bool tolua_ret = (bool)  self->init();
            tolua_pushboolean(tolua_S,(bool)tolua_ret);
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'init'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getKeyframeCallbacks of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_getKeyframeCallbacks00
static int tolua_Cocos2d_CCBAnimationManager_getKeyframeCallbacks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getKeyframeCallbacks'", NULL);
#endif
        {
            CCArray* tolua_ret = (CCArray*)  self->getKeyframeCallbacks();
            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,"CCArray");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getKeyframeCallbacks'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: runAnimationsForSequenceNamedTweenDuration of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_runAnimationsForSequenceNamedTweenDuration00
static int tolua_Cocos2d_CCBAnimationManager_runAnimationsForSequenceNamedTweenDuration00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isstring(tolua_S,2,0,&tolua_err) ||
        !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,4,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
        const char* pName = ((const char*)  tolua_tostring(tolua_S,2,0));
        float fTweenDuration = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'runAnimationsForSequenceNamedTweenDuration'", NULL);
#endif
        {
            self->runAnimationsForSequenceNamedTweenDuration(pName,fTweenDuration);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'runAnimationsForSequenceNamedTweenDuration'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setRootContainerSize of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_setRootContainerSize00
static int tolua_Cocos2d_CCBAnimationManager_setRootContainerSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const CCSize",0,&tolua_err)) ||
        !tolua_isnoobj(tolua_S,3,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
        const CCSize* rootContainerSize = ((const CCSize*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setRootContainerSize'", NULL);
#endif
        {
            self->setRootContainerSize(*rootContainerSize);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'setRootContainerSize'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: runAnimationsForSequenceIdTweenDuration of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_runAnimationsForSequenceIdTweenDuration00
static int tolua_Cocos2d_CCBAnimationManager_runAnimationsForSequenceIdTweenDuration00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
        !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,4,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
        int nSeqId = ((int)  tolua_tonumber(tolua_S,2,0));
        float fTweenDuraiton = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'runAnimationsForSequenceIdTweenDuration'", NULL);
#endif
        {
            self->runAnimationsForSequenceIdTweenDuration(nSeqId,fTweenDuraiton);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'runAnimationsForSequenceIdTweenDuration'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRunningSequenceName of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_getRunningSequenceName00
static int tolua_Cocos2d_CCBAnimationManager_getRunningSequenceName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRunningSequenceName'", NULL);
#endif
        {
            const char* tolua_ret = (const char*)  self->getRunningSequenceName();
            tolua_pushstring(tolua_S,(const char*)tolua_ret);
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getRunningSequenceName'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAutoPlaySequenceId of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_getAutoPlaySequenceId00
static int tolua_Cocos2d_CCBAnimationManager_getAutoPlaySequenceId00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAutoPlaySequenceId'", NULL);
#endif
        {
            int tolua_ret = (int)  self->getAutoPlaySequenceId();
            tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getAutoPlaySequenceId'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addDocumentCallbackName of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_addDocumentCallbackName00
static int tolua_Cocos2d_CCBAnimationManager_addDocumentCallbackName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,3,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
        std::string name = ((std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addDocumentCallbackName'", NULL);
#endif
        {
            self->addDocumentCallbackName(name);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'addDocumentCallbackName'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getRootNode of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_getRootNode00
static int tolua_Cocos2d_CCBAnimationManager_getRootNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,2,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getRootNode'", NULL);
#endif
        {
            CCNode* tolua_ret = (CCNode*)  self->getRootNode();
            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,"CCNode");
        }
    }
    return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'getRootNode'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addDocumentOutletNode of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_addDocumentOutletNode00
static int tolua_Cocos2d_CCBAnimationManager_addDocumentOutletNode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
    tolua_Error tolua_err;
    if (
        !tolua_isusertype(tolua_S,1,"CCBAnimationManager",0,&tolua_err) ||
        !tolua_isusertype(tolua_S,2,"CCNode",0,&tolua_err) ||
        !tolua_isnoobj(tolua_S,3,&tolua_err)
        )
        goto tolua_lerror;
    else
#endif
    {
        CCBAnimationManager* self = (CCBAnimationManager*)  tolua_tousertype(tolua_S,1,0);
        CCNode* node = ((CCNode*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
        if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addDocumentOutletNode'", NULL);
#endif
        {
            self->addDocumentOutletNode(node);
        }
    }
    return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
    tolua_error(tolua_S,"#ferror in function 'addDocumentOutletNode'.",&tolua_err);
    return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addDocumentCallbackNode of class  CCBAnimationManager */
#ifndef TOLUA_DISABLE_tolua_Cocos2d_CCBAnimationManager_addDocum