wxlua_bind.cpp

Go to the documentation of this file.

// ---------------------------------------------------------------------------
// ../modules/wxlua/src/wxlua.cpp was generated by genwxbind.lua 
//
// Any changes made to this file will be lost when the file is regenerated.
// ---------------------------------------------------------------------------

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/wxprec.h"

#ifndef WX_PRECOMP
     #include "wx/wx.h"
#endif


#include "wxlua/include/wxlstate.h"
#include "wxlua/include/wxlua_bind.h"
#ifdef Above
    #undef Above
#endif
#ifdef Below
    #undef Below
#endif


// ---------------------------------------------------------------------------
// Bind class wxLuaState
// ---------------------------------------------------------------------------

// Lua MetaTable Tag for Class 'wxLuaState'
int wxluatype_wxLuaState = WXLUA_TUNKNOWN;

static wxLuaArgType s_wxluatypeArray_wxLua_wxLuaState_delete[] = { &wxluatype_wxLuaState, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxLuaState_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxLuaState_delete }};



// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxLuaState_methods[] = {
    { "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxLuaState_delete, 1, NULL },
    { 0, 0, 0, 0 },
};

int wxLuaState_methodCount = sizeof(wxLuaState_methods)/sizeof(wxLuaBindMethod) - 1;


// ---------------------------------------------------------------------------
// Bind class wxLuaObject
// ---------------------------------------------------------------------------

// Lua MetaTable Tag for Class 'wxLuaObject'
int wxluatype_wxLuaObject = WXLUA_TUNKNOWN;

static wxLuaArgType s_wxluatypeArray_wxLua_wxLuaObject_GetAllocationFlag[] = { &wxluatype_wxLuaObject, NULL };
static int LUACALL wxLua_wxLuaObject_GetAllocationFlag(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxLuaObject_GetAllocationFlag[1] = {{ wxLua_wxLuaObject_GetAllocationFlag, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxLuaObject_GetAllocationFlag }};
//     int  GetAllocationFlag() const
static int LUACALL wxLua_wxLuaObject_GetAllocationFlag(lua_State *L)
{
    // get this
    wxLuaObject * self = (wxLuaObject *)wxluaT_getuserdatatype(L, 1, wxluatype_wxLuaObject);
    // call GetAllocationFlag
    int returns = (self->GetAllocationFlag());
    // push the result number
    lua_pushnumber(L, returns);

    return 1;
}

static wxLuaArgType s_wxluatypeArray_wxLua_wxLuaObject_GetObject[] = { &wxluatype_wxLuaObject, NULL };
static int LUACALL wxLua_wxLuaObject_GetObject(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxLuaObject_GetObject[1] = {{ wxLua_wxLuaObject_GetObject, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxLuaObject_GetObject }};
// %override wxLua_wxLuaObject_GetObject
// void *GetObject() const
static int LUACALL wxLua_wxLuaObject_GetObject(lua_State *L)
{
    // get this
    wxLuaObject *self = (wxLuaObject *)wxluaT_getuserdatatype(L, 1, wxluatype_wxLuaObject);
    // call GetObject that push the item onto the stack, or nil
    if (self->GetObject())
        return 1;

    return 0;
}


static wxLuaArgType s_wxluatypeArray_wxLua_wxLuaObject_SetObject[] = { &wxluatype_wxLuaObject, NULL };
static int LUACALL wxLua_wxLuaObject_SetObject(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxLuaObject_SetObject[1] = {{ wxLua_wxLuaObject_SetObject, WXLUAMETHOD_METHOD, 1, 1, s_wxluatypeArray_wxLua_wxLuaObject_SetObject }};
// %override wxLua_wxLuaObject_SetObject
// void SetObject(void *object)
static int LUACALL wxLua_wxLuaObject_SetObject(lua_State *L)
{
    // get this
    wxLuaObject *self = (wxLuaObject *)wxluaT_getuserdatatype(L, 1, wxluatype_wxLuaObject);
    // call SetObject
    self->SetObject(1);
    // return the number of parameters
    return 0;
}


static wxLuaArgType s_wxluatypeArray_wxLua_wxLuaObject_delete[] = { &wxluatype_wxLuaObject, NULL };
static wxLuaBindCFunc s_wxluafunc_wxLua_wxLuaObject_delete[1] = {{ wxlua_userdata_delete, WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, 1, 1, s_wxluatypeArray_wxLua_wxLuaObject_delete }};

static int LUACALL wxLua_wxLuaObject_constructor(lua_State *L);
static wxLuaBindCFunc s_wxluafunc_wxLua_wxLuaObject_constructor[1] = {{ wxLua_wxLuaObject_constructor, WXLUAMETHOD_CONSTRUCTOR, 0, 0, g_wxluaargtypeArray_None }};
// %override wxLua_wxLuaObject_constructor
// wxLuaObject(void *object)
static int LUACALL wxLua_wxLuaObject_constructor(lua_State *L)
{
    wxLuaState wxlState(L);

    wxLuaObject *returns;
    // call constructor
    returns = new wxLuaObject(wxlState, 1);
    // add to tracked memory list
    wxluaO_addgcobject(L, returns);
    // push the constructed class pointer
    wxluaT_pushuserdatatype(L, returns, wxluatype_wxLuaObject);
    // return the number of parameters
    return 1;
}




// Map Lua Class Methods to C Binding Functions
wxLuaBindMethod wxLuaObject_methods[] = {
    { "GetAllocationFlag", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxLuaObject_GetAllocationFlag, 1, NULL },
    { "GetObject", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxLuaObject_GetObject, 1, NULL },
    { "SetObject", WXLUAMETHOD_METHOD, s_wxluafunc_wxLua_wxLuaObject_SetObject, 1, NULL },
    { "delete", WXLUAMETHOD_METHOD|WXLUAMETHOD_DELETE, s_wxluafunc_wxLua_wxLuaObject_delete, 1, NULL },
    { "wxLuaObject", WXLUAMETHOD_CONSTRUCTOR, s_wxluafunc_wxLua_wxLuaObject_constructor, 1, NULL },
    { 0, 0, 0, 0 },
};

int wxLuaObject_methodCount = sizeof(wxLuaObject_methods)/sizeof(wxLuaBindMethod) - 1;




// ---------------------------------------------------------------------------
// ../modules/wxlua/src/wxlua_bind.cpp was generated by genwxbind.lua 
//
// Any changes made to this file will be lost when the file is regenerated.
// ---------------------------------------------------------------------------


// ---------------------------------------------------------------------------
// wxLuaGetEventList_wxlua() is called to register events
// ---------------------------------------------------------------------------

wxLuaBindEvent* wxLuaGetEventList_wxlua(size_t &count)
{
    static wxLuaBindEvent eventList[] =
    {

        { 0, 0, 0 },
    };
    count = sizeof(eventList)/sizeof(wxLuaBindEvent) - 1;
    return eventList;
}

// ---------------------------------------------------------------------------
// wxLuaGetDefineList_wxlua() is called to register %define and %enum
// ---------------------------------------------------------------------------

wxLuaBindNumber* wxLuaGetDefineList_wxlua(size_t &count)
{
    static wxLuaBindNumber numberList[] =
    {
        { "LUA_TBOOLEAN", LUA_TBOOLEAN },
        { "LUA_TFUNCTION", LUA_TFUNCTION },
        { "LUA_TLIGHTUSERDATA", LUA_TLIGHTUSERDATA },
        { "LUA_TNIL", LUA_TNIL },
        { "LUA_TNONE", LUA_TNONE },
        { "LUA_TNUMBER", LUA_TNUMBER },
        { "LUA_TSTRING", LUA_TSTRING },
        { "LUA_TTABLE", LUA_TTABLE },
        { "LUA_TTHREAD", LUA_TTHREAD },
        { "LUA_TUSERDATA", LUA_TUSERDATA },
        { "WXLUAMETHOD_CFUNCTION", WXLUAMETHOD_CFUNCTION },
        { "WXLUAMETHOD_CHECKED_OVERLOAD", WXLUAMETHOD_CHECKED_OVERLOAD },
        { "WXLUAMETHOD_CONSTRUCTOR", WXLUAMETHOD_CONSTRUCTOR },
        { "WXLUAMETHOD_DELETE", WXLUAMETHOD_DELETE },
        { "WXLUAMETHOD_GETPROP", WXLUAMETHOD_GETPROP },
        { "WXLUAMETHOD_METHOD", WXLUAMETHOD_METHOD },
        { "WXLUAMETHOD_SETPROP", WXLUAMETHOD_SETPROP },
        { "WXLUAMETHOD_STATIC", WXLUAMETHOD_STATIC },
        { "WXLUA_TBOOLEAN", WXLUA_TBOOLEAN },
        { "WXLUA_TCFUNCTION", WXLUA_TCFUNCTION },
        { "WXLUA_TFUNCTION", WXLUA_TFUNCTION },
        { "WXLUA_TINTEGER", WXLUA_TINTEGER },
        { "WXLUA_TLIGHTUSERDATA", WXLUA_TLIGHTUSERDATA },
        { "WXLUA_TNIL", WXLUA_TNIL },
        { "WXLUA_TNONE", WXLUA_TNONE },
        { "WXLUA_TNUMBER", WXLUA_TNUMBER },
        { "WXLUA_TSTRING", WXLUA_TSTRING },
        { "WXLUA_TTABLE", WXLUA_TTABLE },
        { "WXLUA_TTHREAD", WXLUA_TTHREAD },
        { "WXLUA_TUSERDATA", WXLUA_TUSERDATA },
        { "WXLUA_T_MAX", WXLUA_T_MAX },
        { "wxLUAOBJECT_ARRAYINT", wxLUAOBJECT_ARRAYINT },
        { "wxLUAOBJECT_BOOL", wxLUAOBJECT_BOOL },
        { "wxLUAOBJECT_INT", wxLUAOBJECT_INT },
        { "wxLUAOBJECT_NONE", wxLUAOBJECT_NONE },
        { "wxLUAOBJECT_STRING", wxLUAOBJECT_STRING },
        { "wxLUA_MAJOR_VERSION", wxLUA_MAJOR_VERSION },
        { "wxLUA_MINOR_VERSION", wxLUA_MINOR_VERSION },
        { "wxLUA_RELEASE_NUMBER", wxLUA_RELEASE_NUMBER },
        { "wxLUA_SUBRELEASE_NUMBER", wxLUA_SUBRELEASE_NUMBER },

        { 0, 0 },
    };
    count = sizeof(numberList)/sizeof(wxLuaBindNumber) - 1;
    return numberList;
}

// ---------------------------------------------------------------------------

// wxLuaGetStringList_wxlua() is called to register %define %string
// ---------------------------------------------------------------------------

wxLuaBindString* wxLuaGetStringList_wxlua(size_t &count)
{
    static wxLuaBindString stringList[] =
    {
        { "wxLUA_VERSION_STRING", wxLUA_VERSION_STRING },

        { 0, 0 },
    };
    count = sizeof(stringList)/sizeof(wxLuaBindString) - 1;
    return stringList;
}

// ---------------------------------------------------------------------------
// wxLuaGetObjectList_wxlua() is called to register object and pointer bindings
// ---------------------------------------------------------------------------

wxLuaBindObject* wxLuaGetObjectList_wxlua(size_t &count)
{
    static wxLuaBindObject objectList[] =
    {

        { 0, 0, 0, 0 },
    };
    count = sizeof(objectList)/sizeof(wxLuaBindObject) - 1;
    return objectList;
}

// ---------------------------------------------------------------------------
// wxLuaGetFunctionList_wxlua() is called to register global functions
// ---------------------------------------------------------------------------

static wxLuaArgType s_wxluatypeArray_wxLua_function_CompileLuaScript[] = { &wxluatype_TSTRING, &wxluatype_TSTRING, NULL };
// %override wxLua_function_CompileLuaScript
// %function int CompileLuaScript(const wxString& luaScript, const wxString& fileName)
static int LUACALL wxLua_function_CompileLuaScript(lua_State *L)
{
    int returns;
    // const wxString fileName
    const wxString fileName = wxlua_getwxStringtype(L, 2);
    // const wxString luaScript
    const wxString luaScript = wxlua_getwxStringtype(L, 1);
    wxString errMsg;
    int line_num = -1;
    wxLuaState wxlState2(true); // create a brand new empty lua state to compile in
    returns = wxlState2.CompileString(luaScript, fileName, &errMsg, &line_num);
    // push the result number
    lua_pushnumber(L, returns);
    wxlua_pushwxString(L, errMsg);
    lua_pushnumber(L, line_num);
    return 3;
}

static wxLuaBindCFunc s_wxluafunc_wxLua_function_CompileLuaScript[1] = {{ wxLua_function_CompileLuaScript, WXLUAMETHOD_CFUNCTION, 2, 2, s_wxluatypeArray_wxLua_function_CompileLuaScript }};

// %override wxLua_function_GetBindings

int LUACALL wxluabind_wxLuaBinding__index(lua_State* L);

// %function LuaTable GetBindings()
static int LUACALL wxLua_function_GetBindings(lua_State *L)
{
    lua_newtable(L); // the table that we return

    int idx = 1;
    wxLuaBindingList::compatibility_iterator node;
    for (node = wxLuaBinding::GetBindingList()->GetFirst(); node; node = node->GetNext(), idx++)
    {
        wxLuaBinding* binding = node->GetData();

        // Push function to access the binding info
        const void **ptr = (const void **)lua_newuserdata(L, sizeof(void *));
        *ptr = binding;
            lua_newtable(L);
            lua_pushstring(L, "__index");
            lua_pushlightuserdata(L, binding); // push tag to recognize table call
            lua_pushcclosure(L, wxluabind_wxLuaBinding__index, 1);      // push func with tag as upvalue
            lua_rawset(L, -3);

            //lua_pushstring(L, "__metatable");
            //lua_pushstring(L, "Metatable is not accessible");
            //lua_rawset(L, -3);

            lua_setmetatable(L, -2);

        lua_rawseti(L, -2, idx);
    }

    return 1;
}

//-----------------------------------------------------------------------------
// wxluabind_wxLuaBindCFunc__index
//-----------------------------------------------------------------------------
int LUACALL wxluabind_wxLuaBindClass__index(lua_State* L);

int LUACALL wxluabind_wxLuaBindCFunc__index(lua_State* L)
{
    void **ptr = (void **)lua_touserdata(L, 1);
    wxLuaBindCFunc* wxlCFunc= (wxLuaBindCFunc*)*ptr;
    wxLuaBinding *wxlBinding = (wxLuaBinding *)lua_touserdata(L, lua_upvalueindex(1));

    int idx_type = lua_type(L, 2);

    if (idx_type == LUA_TSTRING)
    {
        const char* idx_str = lua_tostring(L, 2);

        if (strcmp(idx_str, "lua_cfunc") == 0)
        {
            lua_pushcfunction(L, wxlCFunc->lua_cfunc);
            return 1;
        }
        else if (strcmp(idx_str, "method_type") == 0)
        {
            lua_pushnumber(L, wxlCFunc->method_type);
            return 1;
        }
        else if (strcmp(idx_str, "minargs") == 0)
        {
            lua_pushnumber(L, wxlCFunc->minargs);
            return 1;
        }
        else if (strcmp(idx_str, "maxargs") == 0)
        {
            lua_pushnumber(L, wxlCFunc->maxargs);
            return 1;
        }
        else if (strcmp(idx_str, "argtypes") == 0)
        {
            size_t idx, count = wxlCFunc->maxargs;
            lua_createtable(L, count, 0);

            // check for terminating null in argtypes
            for (idx = 0; (idx < count) && wxlCFunc->argtypes[idx]; ++idx)
            {
                lua_pushnumber(L, *wxlCFunc->argtypes[idx]);
                lua_rawseti(L, -2, idx + 1);
            }

            return 1;
        }
        else if (strcmp(idx_str, "class") == 0)
        {
            const wxLuaBindClass* c = wxlBinding->GetBindClass(wxlCFunc);
            if (c != NULL)
            {
                const void **ptr = (const void **)lua_newuserdata(L, sizeof(void *));
                *ptr = c;
                    lua_newtable(L);
                    lua_pushstring(L, "__index");
                    lua_pushlightuserdata(L, wxlBinding);
                    lua_pushcclosure(L, wxluabind_wxLuaBindClass__index, 1); // push func with tag as upvalue
                    lua_rawset(L, -3);
                    lua_setmetatable(L, -2);

                return 1;
            }
        }
        else if (strcmp(idx_str, "class_name") == 0)
        {
            const wxLuaBindClass* c = wxlBinding->GetBindClass(wxlCFunc);
            if (c != NULL)
            {
                lua_pushstring(L, c->name);
                return 1;
            }
        }
    }

    return 0;
}

//-----------------------------------------------------------------------------
// wxluabind_wxLuaBindMethod__index
//-----------------------------------------------------------------------------

int LUACALL wxluabind_wxLuaBindMethod__index(lua_State* L)
{
    void **ptr = (void **)lua_touserdata(L, 1);
    wxLuaBindMethod* wxlMethod = (wxLuaBindMethod*)*ptr;
    wxLuaBinding *wxlBinding = (wxLuaBinding *)lua_touserdata(L, lua_upvalueindex(1));

    int idx_type = lua_type(L, 2);

    if (idx_type == LUA_TSTRING)
    {
        const char* idx_str = lua_tostring(L, 2);

        if (strcmp(idx_str, "name") == 0)
        {
            lua_pushstring(L, wxlMethod->name);
            return 1;
        }
        else if (strcmp(idx_str, "method_type") == 0)
        {
            lua_pushnumber(L, wxlMethod->method_type);
            return 1;
        }
        else if (strcmp(idx_str, "wxluacfuncs") == 0)
        {
            wxLuaBindCFunc* wxlCFunc = wxlMethod->wxluacfuncs;
            size_t idx, count = wxlMethod->wxluacfuncs_n;
            lua_createtable(L, count, 0);

            for (idx = 0; idx < count; ++idx, ++wxlCFunc)
            {
                const void **ptr = (const void **)lua_newuserdata(L, sizeof(void *));
                *ptr = wxlCFunc;
                    lua_newtable(L);
                    lua_pushstring(L, "__index");
                    lua_pushlightuserdata(L, wxlBinding);
                    lua_pushcclosure(L, wxluabind_wxLuaBindCFunc__index, 1); // push func with tag as upvalue
                    lua_rawset(L, -3);
                    lua_setmetatable(L, -2);

                lua_rawseti(L, -2, idx + 1);
            }

            return 1;
        }
        else if (strcmp(idx_str, "wxluacfuncs_n") == 0)
        {
            lua_pushnumber(L, wxlMethod->wxluacfuncs_n);
            return 1;
        }
        else if (strcmp(idx_str, "basemethod") == 0)
        {
            if (wxlMethod->basemethod)
            {
                const void **ptr = (const void **)lua_newuserdata(L, sizeof(void *));
                *ptr = wxlMethod->basemethod;
                    lua_newtable(L);
                    lua_pushstring(L, "__index");
                    lua_pushlightuserdata(L, wxlBinding);
                    lua_pushcclosure(L, wxluabind_wxLuaBindMethod__index, 1); // push func with tag as upvalue
                    lua_rawset(L, -3);
                    lua_setmetatable(L, -2);

                return 1;
            }

            return 0;
        }
        else if (strcmp(idx_str, "class") == 0)
        {
            const wxLuaBindClass* c = wxlBinding->GetBindClass(wxlMethod);
            if (c != NULL)
            {
                const void **ptr = (const void **)lua_newuserdata(L, sizeof(void *));
                *ptr = c;
                    lua_newtable(L);
                    lua_pushstring(L, "__index");
                    lua_pushlightuserdata(L, wxlBinding);
                    lua_pushcclosure(L, wxluabind_wxLuaBindClass__index, 1); // push func with tag as upvalue
                    lua_rawset(L, -3);
                    lua_setmetatable(L, -2);

                return 1;
            }
        }
        else if (strcmp(idx_str, "class_name") == 0)
        {
            const wxLuaBindClass* c = wxlBinding->GetBindClass(wxlMethod);
            if (c != NULL)
            {
                lua_pushstring(L, c->name);
                return 1;
            }
        }
    }

    return 0;
}

//-----------------------------------------------------------------------------
// wxluabind_wxLuaBindClass__index
//-----------------------------------------------------------------------------

int LUACALL wxluabind_wxLuaBindClass__index(lua_State* L)
{
    void **ptr = (void **)lua_touserdata(L, 1);
    wxLuaBindClass* wxlClass = (wxLuaBindClass*)*ptr;
    wxLuaBinding *wxlBinding = (wxLuaBinding *)lua_touserdata(L, lua_upvalueindex(1));

    int idx_type = lua_type(L, 2);

    if (idx_type == LUA_TSTRING)
    {
        const char* idx_str = lua_tostring(L, 2);

        if (strcmp(idx_str, "name") == 0)
        {
            lua_pushstring(L, wxlClass->name);
            return 1;
        }
        else if (strcmp(idx_str, "wxluamethods") == 0)
        {
            if (wxlClass->wxluamethods_n > 0)
            {
                wxLuaBindMethod* wxlMethod = wxlClass->wxluamethods;
                size_t idx, count = wxlClass->wxluamethods_n;
                lua_createtable(L, count, 0);

                for (idx = 0; idx < count; ++idx, ++wxlMethod)
                {
                    // Create table { wxLuaBindClass userdata }
                    const void **ptr = (const void **)lua_newuserdata(L, sizeof(void *));
                    *ptr = wxlMethod;
                        lua_newtable(L);
                        lua_pushstring(L, "__index");
                        lua_pushlightuserdata(L, wxlBinding);
                        lua_pushcclosure(L, wxluabind_wxLuaBindMethod__index, 1); // push func with tag as upvalue
                        lua_rawset(L, -3);
                        lua_setmetatable(L, -2);

                    lua_rawseti(L, -2, idx + 1);
                }

                lua_pushstring(L, "wxLuaBindClass"); // so we know where this came from
                lua_pushvalue(L, 1);
                lua_rawset(L, -3);

                return 1;
            }

            return 0;
        }
        else if (strcmp(idx_str, "wxluamethods_n") == 0)
        {
            lua_pushnumber(L, wxlClass->wxluamethods_n);
            return 1;
        }
        else if (strcmp(idx_str, "classInfo") == 0)
        {
            if (wxlClass->classInfo)
            {
                const wxLuaBindClass* classInfoClass = wxluaT_getclass(L, "wxClassInfo");
                if (classInfoClass)
                {
                    wxluaT_pushuserdatatype(L, wxlClass->classInfo, *classInfoClass->wxluatype);
                    return 1;
                }
            }

            return 0;
        }
        else if (strcmp(idx_str, "wxluatype") == 0)
        {
            lua_pushnumber(L, *wxlClass->wxluatype);
            return 1;
        }
        else if (strcmp(idx_str, "baseclassNames") == 0)
        {
            if (wxlClass->baseclassNames)
            {
                lua_newtable(L);
                for (size_t i = 0; wxlClass->baseclassNames[i]; ++i)
                {
                    lua_pushstring(L, wxlClass->baseclassNames[i]);
                    lua_rawseti(L, -2, i + 1);
                }
                return 1;
            }

            return 0;
        }
        else if (strcmp(idx_str, "baseBindClasses") == 0)
        {
            if (wxlClass->baseBindClasses)
            {
                lua_newtable(L);
                for (size_t i = 0; wxlClass->baseclassNames[i]; ++i) // use names to check for terminating NULL
                {
                    if (wxlClass->baseBindClasses[i] == NULL) // may be NULL if not loaded
                    {
                        lua_pushnil(L);
                    }
                    else
                    {
                        const void **ptr = (const void **)lua_newuserdata(L, sizeof(void *));
                        *ptr = wxlClass->baseBindClasses[i];
                            lua_newtable(L);
                            lua_pushstring(L, "__index");
                            lua_pushlightuserdata(L, wxlBinding);
                            lua_pushcclosure(L, wxluabind_wxLuaBindClass__index, 1); // push func with tag as upvalue
                            lua_rawset(L, -3);
                            lua_setmetatable(L, -2);
                    }

                    lua_rawseti(L, -2, i + 1);
                }

                return 1;
            }

            return 0;
        }
        else if (strcmp(idx_str, "enums") == 0)
        {
            if (wxlClass->enums_n > 0)
            {
                wxLuaBindNumber* wxlNumber = wxlClass->enums;
                size_t idx, count = wxlClass->enums_n;
                lua_createtable(L, count, 0);

                for (idx = 0; idx < count; ++idx, ++wxlNumber)
                {
                    // Create table { name, value }
                    lua_createtable(L, 0, 2);
                    lua_pushstring(L, "name");
                    lua_pushstring(L, wxlNumber->name);
                    lua_rawset(L, -3);
                    lua_pushstring(L, "value");
                    lua_pushnumber(L, wxlNumber->value);
                    lua_rawset(L, -3);

                    lua_rawseti(L, -2, idx + 1);
                }

                lua_pushstring(L, "wxLuaBindClass"); // so we know where this came from
                lua_pushvalue(L, 1);
                lua_rawset(L, -3);

                return 1;
            }

            return 0;
        }
        else if (strcmp(idx_str, "enums_n") == 0)
        {
            lua_pushnumber(L, wxlClass->enums_n);
            return 1;
        }
    }

    return 0;
}

//-----------------------------------------------------------------------------
// wxluabind_wxLuaBinding__index
//-----------------------------------------------------------------------------

int LUACALL wxluabind_wxLuaBinding__index(lua_State* L)
{
    void **ptr = (void **)lua_touserdata(L, 1);
    wxLuaBinding* wxlBinding = (wxLuaBinding*)*ptr;

    int idx_type = lua_type(L, 2);

    if (idx_type == LUA_TSTRING)
    {
        const char* idx_str = lua_tostring(L, 2);

        if (strcmp(idx_str, "GetBindingName") == 0)
        {
            lua_pushstring(L, wx2lua(wxlBinding->GetBindingName()));
            return 1;
        }
        else if (strcmp(idx_str, "GetLuaNamespace") == 0)
        {
            lua_pushstring(L, wx2lua(wxlBinding->GetLuaNamespace()));
            return 1;
        }
        else if (strcmp(idx_str, "GetClassCount") == 0)
        {
            lua_pushnumber(L, wxlBinding->GetClassCount());
            return 1;
        }
        else if (strcmp(idx_str, "GetNumberCount") == 0)
        {
            lua_pushnumber(L, wxlBinding->GetNumberCount());
            return 1;
        }
        else if (strcmp(idx_str, "GetStringCount") == 0)
        {
            lua_pushnumber(L, wxlBinding->GetStringCount());
            return 1;
        }
        else if (strcmp(idx_str, "GetEventCount") == 0)
        {
            lua_pushnumber(L, wxlBinding->GetEventCount());
            return 1;
        }
        else if (strcmp(idx_str, "GetObjectCount") == 0)
        {
            lua_pushnumber(L, wxlBinding->GetObjectCount());
            return 1;
        }
        else if (strcmp(idx_str, "GetFunctionCount") == 0)
        {
            lua_pushnumber(L, wxlBinding->GetFunctionCount());
            return 1;
        }
        else if (strcmp(idx_str, "GetClassArray") == 0)
        {
            wxLuaBindClass* wxlClass = wxlBinding->GetClassArray();
            size_t idx, count = wxlBinding->GetClassCount();
            lua_createtable(L, count, 0);

            for (idx = 0; idx < count; ++idx, ++wxlClass)
            {
                // Create table { wxLuaBindClass userdata }
                const void **ptr = (const void **)lua_newuserdata(L, sizeof(void *));
                *ptr = wxlClass;
                    lua_newtable(L);
                    lua_pushstring(L, "__index");
                    lua_pushlightuserdata(L, wxlBinding);
                    lua_pushcclosure(L, wxluabind_wxLuaBindClass__index, 1); // push func with tag as upvalue
                    lua_rawset(L, -3);
                    lua_setmetatable(L, -2);

                lua_rawseti(L, -2, idx + 1);
            }

            return 1;
        }
        else if (strcmp(idx_str, "GetFunctionArray") == 0)
        {
            wxLuaBindMethod* wxlMethod = wxlBinding->GetFunctionArray();
            size_t idx, count = wxlBinding->GetFunctionCount();
            lua_createtable(L, count, 0);

            for (idx = 0; idx < count; ++idx, ++wxlMethod)
            {
                // Create table { wxLuaBindClass userdata }
                const void **ptr = (const void **)lua_newuserdata(L, sizeof(void *));
                *ptr = wxlMethod;
                    lua_newtable(L);
                    lua_pushstring(L, "__index");
                    lua_pushlightuserdata(L, wxlBinding);
                    lua_pushcclosure(L, wxluabind_wxLuaBindMethod__index, 1); // push func with tag as upvalue
                    lua_rawset(L, -3);
                    lua_setmetatable(L, -2);

                lua_rawseti(L, -2, idx + 1);
            }

            return 1;
        }
        else if (strcmp(idx_str, "GetNumberArray") == 0)
        {
            wxLuaBindNumber* wxlNumber = wxlBinding->GetNumberArray();
            size_t idx, count = wxlBinding->GetNumberCount();
            lua_createtable(L, count, 0);

            for (idx = 0; idx < count; ++idx, ++wxlNumber)
            {
                // Create table { name, value }
                lua_createtable(L, 0, 2);
                lua_pushstring(L, "name");
                lua_pushstring(L, wxlNumber->name);
                lua_rawset(L, -3);
                lua_pushstring(L, "value");
                lua_pushnumber(L, wxlNumber->value);
                lua_rawset(L, -3);

                lua_rawseti(L, -2, idx + 1);
            }

            return 1;
        }
        else if (strcmp(idx_str, "GetStringArray") == 0)
        {
            wxLuaBindString* wxlString = wxlBinding->GetStringArray();
            size_t idx, count = wxlBinding->GetStringCount();
            lua_createtable(L, count, 0);

            for (idx = 0; idx < count; ++idx, ++wxlString)
            {
                // Create table { name, value }
                lua_createtable(L, 0, 2);
                lua_pushstring(L, "name");
                lua_pushstring(L, wxlString->name);
                lua_rawset(L, -3);
                lua_pushstring(L, "value");
                lua_pushstring(L, wx2lua(wxlString->value));
                lua_rawset(L, -3);

                lua_rawseti(L, -2, idx + 1);
            }

            return 1;
        }
        else if (strcmp(idx_str, "GetEventArray") == 0)
        {
            wxLuaBindEvent* wxlEvent = wxlBinding->GetEventArray();
            size_t idx, count = wxlBinding->GetEventCount();
            lua_createtable(L, count, 0);

            for (idx = 0; idx < count; ++idx, ++wxlEvent)
            {
                // Create table { name, eventType, wxluatype }
                lua_createtable(L, 0, 3);
                lua_pushstring(L, "name");
                lua_pushstring(L, wxlEvent->name);
                lua_rawset(L, -3);
                lua_pushstring(L, "eventType");
                lua_pushnumber(L, *wxlEvent->eventType);
                lua_rawset(L, -3);
                lua_pushstring(L, "wxluatype");
                lua_pushnumber(L, *wxlEvent->wxluatype);
                lua_rawset(L, -3);

                lua_pushstring(L, "wxLuaBindClass");
                const wxLuaBindClass* wxlClass = wxlBinding->GetBindClass(*wxlEvent->wxluatype);
                if (wxlClass == NULL)
                {
                    lua_pushnil(L);
                }
                else
                {
                    const void **ptr = (const void **)lua_newuserdata(L, sizeof(void *));
                    *ptr = wxlClass;
                        lua_newtable(L);
                        lua_pushstring(L, "__index");
                        lua_pushlightuserdata(L, wxlBinding);
                        lua_pushcclosure(L, wxluabind_wxLuaBindClass__index, 1); // push func with tag as upvalue
                        lua_rawset(L, -3);
                        lua_setmetatable(L, -2);
                }
                lua_rawset(L, -3);

                lua_rawseti(L, -2, idx + 1);
            }

            return 1;
        }
        else if (strcmp(idx_str, "GetObjectArray") == 0)
        {
            wxLuaBindObject* wxlObject = wxlBinding->GetObjectArray();
            size_t idx, count = wxlBinding->GetObjectCount();
            lua_createtable(L, count, 0);

            for (idx = 0; idx < count; ++idx, ++wxlObject)
            {
                // Create table { name, object, wxluatype }
                lua_createtable(L, 0, 3);
                lua_pushstring(L, "name");
                lua_pushstring(L, wxlObject->name);
                lua_rawset(L, -3);

                lua_pushstring(L, "object");
                if (wxlObject->objPtr != 0)
                    wxluaT_pushuserdatatype(L, wxlObject->objPtr, *wxlObject->wxluatype, false);
                else
                    wxluaT_pushuserdatatype(L, *wxlObject->pObjPtr, *wxlObject->wxluatype, false);
                lua_rawset(L, -3);

                lua_pushstring(L, "wxluatype");
                lua_pushnumber(L, *wxlObject->wxluatype);
                lua_rawset(L, -3);

                lua_pushstring(L, "wxLuaBindClass");
                const wxLuaBindClass* wxlClass = wxlBinding->GetBindClass(*wxlObject->wxluatype);
                if (wxlClass == NULL)
                {
                    lua_pushnil(L);
                }
                else
                {
                    const void **ptr = (const void **)lua_newuserdata(L, sizeof(void *));
                    *ptr = wxlClass;
                        lua_newtable(L);
                        lua_pushstring(L, "__index");
                        lua_pushlightuserdata(L, wxlBinding);
                        lua_pushcclosure(L, wxluabind_wxLuaBindClass__index, 1); // push func with tag as upvalue
                        lua_rawset(L, -3);
                        lua_setmetatable(L, -2);
                }
                lua_rawset(L, -3);

                lua_rawseti(L, -2, idx + 1);
            }

            return 1;
        }
    }

    return 0;
}


static wxLuaBindCFunc s_wxluafunc_wxLua_function_GetBindings[1] = {{ wxLua_function_GetBindings, WXLUAMETHOD_CFUNCTION, 0, 0, g_wxluaargtypeArray_None }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_GetGCUserdataInfo[] = { &wxluatype_TBOOLEAN, NULL };
// %override wxLua_function_GetGCUserdataInfo
// %function LuaTable GetGCUserdataInfo(bool as_string = false)
static int LUACALL wxLua_function_GetGCUserdataInfo(lua_State *L)
{
    bool as_string = lua_toboolean(L, 1); // ok if nil
    if (as_string)
        wxlua_pushwxString(L, wxlua_concatwxArrayString(wxluaO_getgcobjectinfo(L)));
    else
        wxlua_pushwxArrayStringtable(L, wxluaO_getgcobjectinfo(L));

    return 1;
}

static wxLuaBindCFunc s_wxluafunc_wxLua_function_GetGCUserdataInfo[1] = {{ wxLua_function_GetGCUserdataInfo, WXLUAMETHOD_CFUNCTION, 0, 1, s_wxluatypeArray_wxLua_function_GetGCUserdataInfo }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_GetTrackedEventCallbackInfo[] = { &wxluatype_TBOOLEAN, NULL };
// %override wxLua_function_GetTrackedEventCallbackInfo
// %function LuaTable GetTrackedEventCallbackInfo(bool as_string = false)
static int LUACALL wxLua_function_GetTrackedEventCallbackInfo(lua_State *L)
{
    wxLuaState wxlState(L);
    bool as_string = lua_toboolean(L, 1); // ok if nil
    if (as_string)
        wxlua_pushwxString(L, wxlua_concatwxArrayString(wxlState.GetTrackedEventCallbackInfo()));
    else
        wxlua_pushwxArrayStringtable(L, wxlState.GetTrackedEventCallbackInfo());

    return 1;
}

static wxLuaBindCFunc s_wxluafunc_wxLua_function_GetTrackedEventCallbackInfo[1] = {{ wxLua_function_GetTrackedEventCallbackInfo, WXLUAMETHOD_CFUNCTION, 0, 1, s_wxluatypeArray_wxLua_function_GetTrackedEventCallbackInfo }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_GetTrackedObjectInfo[] = { &wxluatype_TBOOLEAN, NULL };
// %override wxLua_function_GetTrackedObjectInfo
// %function LuaTable GetTrackedObjectInfo(bool as_string = false)
static int LUACALL wxLua_function_GetTrackedObjectInfo(lua_State *L)
{
    bool as_string = lua_toboolean(L, 1); // ok if nil
    if (as_string)
        wxlua_pushwxString(L, wxlua_concatwxArrayString(wxluaO_gettrackedweakobjectinfo(L)));
    else
        wxlua_pushwxArrayStringtable(L, wxluaO_gettrackedweakobjectinfo(L));

    return 1;
}

static wxLuaBindCFunc s_wxluafunc_wxLua_function_GetTrackedObjectInfo[1] = {{ wxLua_function_GetTrackedObjectInfo, WXLUAMETHOD_CFUNCTION, 0, 1, s_wxluatypeArray_wxLua_function_GetTrackedObjectInfo }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_GetTrackedWinDestroyCallbackInfo[] = { &wxluatype_TBOOLEAN, NULL };
// %override wxLua_function_GetTrackedWinDestroyCallbackInfo
// %function LuaTable GetTrackedWinDestroyCallbackInfo(bool as_string = false)
static int LUACALL wxLua_function_GetTrackedWinDestroyCallbackInfo(lua_State *L)
{
    wxLuaState wxlState(L);
    bool as_string = lua_toboolean(L, 1); // ok if nil
    if (as_string)
        wxlua_pushwxString(L, wxlua_concatwxArrayString(wxlState.GetTrackedWinDestroyCallbackInfo()));
    else
        wxlua_pushwxArrayStringtable(L, wxlState.GetTrackedWinDestroyCallbackInfo());

    return 1;
}

static wxLuaBindCFunc s_wxluafunc_wxLua_function_GetTrackedWinDestroyCallbackInfo[1] = {{ wxLua_function_GetTrackedWinDestroyCallbackInfo, WXLUAMETHOD_CFUNCTION, 0, 1, s_wxluatypeArray_wxLua_function_GetTrackedWinDestroyCallbackInfo }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_GetTrackedWindowInfo[] = { &wxluatype_TBOOLEAN, NULL };
// %override wxLua_function_GetTrackedWindowInfo
// %function LuaTable GetTrackedWindowInfo(bool as_string = false)
static int LUACALL wxLua_function_GetTrackedWindowInfo(lua_State *L)
{
    bool as_string = lua_toboolean(L, 1); // ok if nil
    if (as_string)
        wxlua_pushwxString(L, wxlua_concatwxArrayString(wxluaW_gettrackedwindowinfo(L)));
    else
        wxlua_pushwxArrayStringtable(L, wxluaW_gettrackedwindowinfo(L));

    return 1;
}

static wxLuaBindCFunc s_wxluafunc_wxLua_function_GetTrackedWindowInfo[1] = {{ wxLua_function_GetTrackedWindowInfo, WXLUAMETHOD_CFUNCTION, 0, 1, s_wxluatypeArray_wxLua_function_GetTrackedWindowInfo }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_isgcobject[] = { &wxluatype_TLIGHTUSERDATA, NULL };
// %override wxLua_function_isgcobject
// %function bool isgcobject(void* object)
static int LUACALL wxLua_function_isgcobject(lua_State *L)
{
    bool ret = false;
    if (wxlua_iswxuserdatatype(wxluaT_type(L, 1)))
    {
        void* obj_ptr = wxlua_touserdata(L, 1, false);
        ret = wxluaO_isgcobject(L, obj_ptr);
    }

    lua_pushboolean(L, ret);
    return 1;
}

static wxLuaBindCFunc s_wxluafunc_wxLua_function_isgcobject[1] = {{ wxLua_function_isgcobject, WXLUAMETHOD_CFUNCTION, 1, 1, s_wxluatypeArray_wxLua_function_isgcobject }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_isrefed[] = { &wxluatype_TLIGHTUSERDATA, NULL };
// %override wxLua_function_isrefed
// %function bool isrefed(void* object)
static int LUACALL wxLua_function_isrefed(lua_State *L)
{
    bool ret = wxluaR_isrefed(L, 1, &wxlua_lreg_refs_key) != LUA_NOREF;

    lua_pushboolean(L, ret);
    return 1;
}

static wxLuaBindCFunc s_wxluafunc_wxLua_function_isrefed[1] = {{ wxLua_function_isrefed, WXLUAMETHOD_CFUNCTION, 1, 1, s_wxluatypeArray_wxLua_function_isrefed }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_istrackedobject[] = { &wxluatype_TLIGHTUSERDATA, NULL };
// %override wxLua_function_istrackedobject
// %function bool istrackedobject(void* object)
static int LUACALL wxLua_function_istrackedobject(lua_State *L)
{
    bool ret = false;
    int wxl_type = wxluaT_type(L, 1);

    if (wxlua_iswxuserdatatype(wxl_type))
    {
        void* obj_ptr = wxlua_touserdata(L, 1, false);
        ret = wxluaO_istrackedweakobject(L, obj_ptr, wxl_type, false);
    }

    lua_pushboolean(L, ret);
    return 1;
}

static wxLuaBindCFunc s_wxluafunc_wxLua_function_istrackedobject[1] = {{ wxLua_function_istrackedobject, WXLUAMETHOD_CFUNCTION, 1, 1, s_wxluatypeArray_wxLua_function_istrackedobject }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_iswxluatype[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
// %rename iswxluatype %function int wxlua_iswxluatype(int luatype, int wxluaarg_tag)
static int LUACALL wxLua_function_iswxluatype(lua_State *L)
{
    // int wxluaarg_tag
    int wxluaarg_tag = (int)wxlua_getnumbertype(L, 2);
    // int luatype
    int luatype = (int)wxlua_getnumbertype(L, 1);
    // call wxlua_iswxluatype
    int returns = (wxlua_iswxluatype(luatype, wxluaarg_tag));
    // push the result number
    lua_pushnumber(L, returns);

    return 1;
}
static wxLuaBindCFunc s_wxluafunc_wxLua_function_iswxluatype[1] = {{ wxLua_function_iswxluatype, WXLUAMETHOD_CFUNCTION, 2, 2, s_wxluatypeArray_wxLua_function_iswxluatype }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_type[] = { &wxluatype_TLIGHTUSERDATA, NULL };
// %override wxLua_function_type
// %function int type(int wxluaarg_tag)
static int LUACALL wxLua_function_type(lua_State *L)
{
    int ltype = lua_type(L, 1);
    const char* ltypename = lua_typename(L, ltype);

    int wxl_type = wxluaT_type(L, 1);
    wxString wxltypeName = wxluaT_typename(L, wxl_type);

    // push the results
    lua_pushstring(L, wx2lua(wxltypeName));
    lua_pushnumber(L, wxl_type);

    lua_pushstring(L, ltypename);
    lua_pushnumber(L, ltype);

    return 4;
}

static wxLuaBindCFunc s_wxluafunc_wxLua_function_type[1] = {{ wxLua_function_type, WXLUAMETHOD_CFUNCTION, 1, 1, s_wxluatypeArray_wxLua_function_type }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_typename[] = { &wxluatype_TNUMBER, NULL };
// %override wxLua_function_typename
// %function wxString typename(int wxluaarg_tag)
static int LUACALL wxLua_function_typename(lua_State *L)
{
    // int wxluaarg_tag
    int wxl_type = (int)wxlua_getnumbertype(L, 1);
    // call wxlua_getwxluatypename
    wxString returns = wxluaT_typename(L, wxl_type);
    // push the result string
    wxlua_pushwxString(L, returns);

    return 1;
}

static wxLuaBindCFunc s_wxluafunc_wxLua_function_typename[1] = {{ wxLua_function_typename, WXLUAMETHOD_CFUNCTION, 1, 1, s_wxluatypeArray_wxLua_function_typename }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_ungcobject[] = { &wxluatype_TLIGHTUSERDATA, NULL };
// %override wxLua_function_ungcobject
// %function bool ungcobject(void* object)
static int LUACALL wxLua_function_ungcobject(lua_State *L)
{
    bool ret = false;

    int l_type = lua_type(L, 1);

    if (!wxlua_iswxluatype(l_type, WXLUA_TUSERDATA))
        wxlua_argerror(L, 1, wxT("a 'userdata'"));

    void* o = wxlua_touserdata(L, 1, false);

    if (wxluaO_isgcobject(L, o))
    {
        ret = wxluaO_undeletegcobject(L, o);
    }

    lua_pushboolean(L, ret);
    return 1;
}

static wxLuaBindCFunc s_wxluafunc_wxLua_function_ungcobject[1] = {{ wxLua_function_ungcobject, WXLUAMETHOD_CFUNCTION, 1, 1, s_wxluatypeArray_wxLua_function_ungcobject }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_wxLUA_CHECK_VERSION[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
// %function bool wxLUA_CHECK_VERSION(int major, int minor, int release) // actually a define
static int LUACALL wxLua_function_wxLUA_CHECK_VERSION(lua_State *L)
{
    // int release
    int release = (int)wxlua_getnumbertype(L, 3);
    // int minor
    int minor = (int)wxlua_getnumbertype(L, 2);
    // int major
    int major = (int)wxlua_getnumbertype(L, 1);
    // call wxLUA_CHECK_VERSION
    bool returns = (wxLUA_CHECK_VERSION(major, minor, release));
    // push the result flag
    lua_pushboolean(L, returns);

    return 1;
}
static wxLuaBindCFunc s_wxluafunc_wxLua_function_wxLUA_CHECK_VERSION[1] = {{ wxLua_function_wxLUA_CHECK_VERSION, WXLUAMETHOD_CFUNCTION, 3, 3, s_wxluatypeArray_wxLua_function_wxLUA_CHECK_VERSION }};

static wxLuaArgType s_wxluatypeArray_wxLua_function_wxLUA_CHECK_VERSION_FULL[] = { &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, &wxluatype_TNUMBER, NULL };
// %function bool wxLUA_CHECK_VERSION_FULL(int major, int minor, int release, int subrel) // actually a define
static int LUACALL wxLua_function_wxLUA_CHECK_VERSION_FULL(lua_State *L)
{
    // int subrel
    int subrel = (int)wxlua_getnumbertype(L, 4);
    // int release
    int release = (int)wxlua_getnumbertype(L, 3);
    // int minor
    int minor = (int)wxlua_getnumbertype(L, 2);
    // int major
    int major = (int)wxlua_getnumbertype(L, 1);
    // call wxLUA_CHECK_VERSION_FULL
    bool returns = (wxLUA_CHECK_VERSION_FULL(major, minor, release, subrel));
    // push the result flag
    lua_pushboolean(L, returns);

    return 1;
}
static wxLuaBindCFunc s_wxluafunc_wxLua_function_wxLUA_CHECK_VERSION_FULL[1] = {{ wxLua_function_wxLUA_CHECK_VERSION_FULL, WXLUAMETHOD_CFUNCTION, 4, 4, s_wxluatypeArray_wxLua_function_wxLUA_CHECK_VERSION_FULL }};

// ---------------------------------------------------------------------------
// wxLuaGetFunctionList_wxlua() is called to register global functions
// ---------------------------------------------------------------------------

wxLuaBindMethod* wxLuaGetFunctionList_wxlua(size_t &count)
{
    static wxLuaBindMethod functionList[] =
    {
        { "CompileLuaScript", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_CompileLuaScript, 1, NULL },
        { "GetBindings", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_GetBindings, 1, NULL },
        { "GetGCUserdataInfo", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_GetGCUserdataInfo, 1, NULL },
        { "GetTrackedEventCallbackInfo", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_GetTrackedEventCallbackInfo, 1, NULL },
        { "GetTrackedObjectInfo", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_GetTrackedObjectInfo, 1, NULL },
        { "GetTrackedWinDestroyCallbackInfo", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_GetTrackedWinDestroyCallbackInfo, 1, NULL },
        { "GetTrackedWindowInfo", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_GetTrackedWindowInfo, 1, NULL },
        { "isgcobject", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_isgcobject, 1, NULL },
        { "isrefed", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_isrefed, 1, NULL },
        { "istrackedobject", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_istrackedobject, 1, NULL },
        { "iswxluatype", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_iswxluatype, 1, NULL },
        { "type", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_type, 1, NULL },
        { "typename", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_typename, 1, NULL },
        { "ungcobject", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_ungcobject, 1, NULL },
        { "wxLUA_CHECK_VERSION", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_wxLUA_CHECK_VERSION, 1, NULL },
        { "wxLUA_CHECK_VERSION_FULL", WXLUAMETHOD_CFUNCTION, s_wxluafunc_wxLua_function_wxLUA_CHECK_VERSION_FULL, 1, NULL },

        { 0, 0, 0, 0 }, 
    };
    count = sizeof(functionList)/sizeof(wxLuaBindMethod) - 1;
    return functionList;
}



// ---------------------------------------------------------------------------
// wxLuaGetClassList_wxlua() is called to register classes
// ---------------------------------------------------------------------------

static const char* wxluaclassname_wxLuaObject = "wxLuaObject";
static const char* wxluaclassname_wxLuaState = "wxLuaState";
static const char* wxluaclassname_wxObject = "wxObject";

static const char* wxluabaseclassnames_wxLuaObject[] = { wxluaclassname_wxObject, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxLuaObject[] = { NULL };
static const char* wxluabaseclassnames_wxLuaState[] = { wxluaclassname_wxObject, NULL };
static wxLuaBindClass* wxluabaseclassbinds_wxLuaState[] = { NULL };
// ---------------------------------------------------------------------------
// Lua Tag Method Values and Tables for each Class
// ---------------------------------------------------------------------------

extern wxLuaBindMethod wxLuaObject_methods[];
extern int wxLuaObject_methodCount;
extern wxLuaBindMethod wxLuaState_methods[];
extern int wxLuaState_methodCount;




wxLuaBindClass* wxLuaGetClassList_wxlua(size_t &count)
{
    static wxLuaBindClass classList[] =
    {
        { wxluaclassname_wxLuaObject, wxLuaObject_methods, wxLuaObject_methodCount, CLASSINFO(wxLuaObject), &wxluatype_wxLuaObject, wxluabaseclassnames_wxLuaObject, wxluabaseclassbinds_wxLuaObject, g_wxluanumberArray_None, 0, }, 
        { wxluaclassname_wxLuaState, wxLuaState_methods, wxLuaState_methodCount, CLASSINFO(wxLuaState), &wxluatype_wxLuaState, wxluabaseclassnames_wxLuaState, wxluabaseclassbinds_wxLuaState, g_wxluanumberArray_None, 0, }, 

        { 0, 0, 0, 0, 0, 0, 0 }, 
    };
    count = sizeof(classList)/sizeof(wxLuaBindClass) - 1;

    return classList;
}

// ---------------------------------------------------------------------------
// wxLuaBinding_wxlua() - the binding class
// ---------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxLuaBinding_wxlua, wxLuaBinding)

wxLuaBinding_wxlua::wxLuaBinding_wxlua() : wxLuaBinding()
{
    m_bindingName   = wxT("wxlua");
    m_nameSpace     = wxT("wxlua");
    m_classArray    = wxLuaGetClassList_wxlua(m_classCount);
    m_numberArray   = wxLuaGetDefineList_wxlua(m_numberCount);
    m_stringArray   = wxLuaGetStringList_wxlua(m_stringCount);
    m_eventArray    = wxLuaGetEventList_wxlua(m_eventCount);
    m_objectArray   = wxLuaGetObjectList_wxlua(m_objectCount);
    m_functionArray = wxLuaGetFunctionList_wxlua(m_functionCount);
}

bool wxLuaBinding_wxlua::RegisterBinding(const wxLuaState& wxlState)
{
    bool ret = wxLuaBinding::RegisterBinding(wxlState);

    lua_State* L = wxlState.GetLuaState();

    lua_pushlstring(L, "NULL", 4);
    wxluaT_pushuserdatatype(L, NULL, wxluatype_NULL, true, true);
    lua_rawset(L, -3); // set t["NULL"] = userdata(NULL) w/ NULL tag

    return ret;
}


// ---------------------------------------------------------------------------

bool wxLuaBinding_wxlua_init()
{
    static wxLuaBinding_wxlua m_binding;
    if (wxLuaBinding::GetBindingList()->Find(&m_binding)) return false;

    wxLuaBinding::GetBindingList()->Append(&m_binding);
    return true;
}