wxluascript.h

Go to the documentation of this file.

/***************************************************************
 * Name:      wxluascript.h
 * Purpose:   Defines a lua scripting object
 * Author:    Daniel Nell (daniel.nell@nellresearch.de)
 * Created:   2009-11-11
 * Copyright: Daniel Nell (www.nellresearch.de)
 * License:   wxWindows license
 **************************************************************/

#ifndef WXLUASCRIPT_H
#define WXLUASCRIPT_H

// Additional wxWidgets header file(s).
#if __WXLUASCRIPT_DYNAMIC__
#   include <wx/dynlib.h>
#endif // __WXLUASCRIPT_DYNAMIC__
#include <wx/event.h>

// Include Lua header file(s).
#include "lua5.1/lua.hpp"


/////////////////////////////////////////////////////////////////////////////
//  Defines
//
#if __WXLUASCRIPT_DYNAMIC__
#   define WXLUASCRIPT_LIBLUA    "lua5.1"
#endif // __WXLUASCRIPT_DYNAMIC__


/////////////////////////////////////////////////////////////////////////////
//  Class wxLuaScript
//
/// \brief A class to handle Lua scripting.
///
/// ...
class wxLuaScript
{
  public:
    /// \brief Standard constructor.
    ///
    /// \param strScript            The Lua source code of the script to execute.
    ///                             Default is the empty string.
    /// \param poParent             A pointer to the parent event handler (mostly
    ///                             a window), may be NULL
    /// \param strDomain            The name of the domain (the table name where
    ///                             to register the functions).
    ///                             Default is the empty string.
    /// \param pbParentState        A pointer to a boolean to get the error state,
    ///                             may be NULL
    wxLuaScript( const wxString& strScript= wxEmptyString,
                 wxEvtHandler *poParent= NULL,
                 const wxString& strDomain= wxEmptyString,
                 bool *pbParentState= NULL );

    /// \brief Virtual destructor.
    virtual ~wxLuaScript();

  public:
    /// \brief Run the Lua script in memory.
    virtual void Run()
    {
        // Run the script.
        lua_cpcall( L, wxLuaScript::Run, NULL );
    }

    /// \brief Register a new (LuaC-)function to Lua.
    ///
    /// \param strLuaCFunctionName  the function's name in Lua
    /// \param pLuaCFunction        a pointer to the LuaC-function
    virtual void RegisterFunction( const wxString& strLuaCFunctionName, lua_CFunction pLuaCFunction )
    {
        if( m_strDomain.IsEmpty() )
        {
            lua_register( L, strLuaCFunctionName.char_str(), pLuaCFunction );
        }
        else
        {
            RegisterFunction( L, m_strDomain.char_str(), strLuaCFunctionName.char_str(), pLuaCFunction );
        }
    }

    /// \brief Register a string constant to Lua.
    ///
    /// \param strLuaConstantName   the constant's name in Lua
    /// \param strValue             the constant's value as string
    virtual void RegisterConstant( const wxString& strLuaConstantName, const wxString& strValue )
    {
        lua_pushstring( L, strLuaConstantName.char_str() );
        lua_pushstring( L, strValue.char_str() );
        lua_settable( L, LUA_GLOBALSINDEX );
    }

    /// \brief Register an integer constant to Lua.
    ///
    /// \param strLuaConstantName   the constant's name in Lua
    /// \param nValue               the constant's value as integer
    virtual void RegisterConstant( const wxString& strLuaConstantName, const int nValue )
    {
        lua_pushstring( L, strLuaConstantName.char_str() );
        lua_pushinteger( L, nValue );
        lua_settable( L, LUA_GLOBALSINDEX );
    }

    /// \brief Register an integer variable to Lua.
    ///
    /// \param strLuaVarName        the variable's name in Lua
    /// \param pnValue              a pointer to the integer variable
    virtual void RegisterVariable( const wxString& strLuaVarName, const int *pnValue );

    /// \brief Register a boolean variable to Lua.
    ///
    /// \param strLuaVarName        the variable's name in Lua
    /// \param pnValue              a pointer to the boolean variable
    virtual void RegisterVariable( const wxString& strLuaVarName, const bool *pnValue );

    /// \brief Register a double variable to Lua.
    ///
    /// \param strLuaVarName        the variable's name in Lua
    /// \param pnValue              a pointer to the double variable
    virtual void RegisterVariable( const wxString& strLuaVarName, const double *pnValue );

    /// \brief Register a wxString variable to Lua.
    ///
    /// \param strLuaVarName        the variable's name in Lua
    /// \param pstrValue            a pointer to the string variable
    virtual void RegisterVariable( const wxString& strLuaVarName, const wxString *pstrValue );

    /// \brief Call a Lua function without return value (sometimes called a 'procedure') by given name.
    ///
    /// \param strLuaFunction       the Lua function name to call
    virtual void CallLuaFunction( const wxString& strLuaFunction )
    {
        lua_getfield( L, LUA_GLOBALSINDEX, strLuaFunction.char_str() );
        lua_call( L, 0, 0 );
    }

  protected:
    // Static helper function(s).
    /// \brief Register a new (LuaC-)function to Lua. Lower level function.
    ///
    /// \param L                    a pointer to the Lua context.
    /// \param pszTableName         the table name where the function is assigned
    ///                             to (a kind of domain)
    /// \param pszFuncName          the name of the C function
    /// \param pLuaCFunction        a pointer to the C function
    static void RegisterFunction( lua_State* L, const char *pszTableName,
                                  const char *pszFuncName, lua_CFunction pLuaCFunction);

    /// \brief Get the this-pointer from Lua.
    ///
    /// \param L                    a pointer to the Lua context.
    static wxLuaScript *GetThis( lua_State* L );

    /// \brief Run the Lua script in memory in protected mode.
    ///
    /// \param L                    a pointer to the Lua context.
    static int Run( lua_State* L );

    /// \brief Create a stack trace on the Lua stack.
    ///
    /// \param L                    a pointer to the Lua context.
    static int TraceBack( lua_State* L );

  protected:
    // Functions accessible by the Lua language.
    /// \brief Error handler for (maybe fatal) Lua errors.
    ///
    /// \param L                    a pointer to the Lua context.
    static int LuaAtPanic( lua_State* L );

    /// \brief Log a message on the standard wxWidgets log target.
    ///
    /// \param L                    a pointer to the Lua context.
    static int LogMessage( lua_State* L );

    /// \brief Send a menu event to the parent event handler.
    ///
    /// \param L                    a pointer to the Lua context.
    static int SendMenuEvent( lua_State* L );

    /// \brief Accessor function to a C-closure bound integer on the C/C++ side
    ///
    /// \param L                    a pointer to the Lua context.
    static int LuaIntVarAccessor( lua_State *L );

    /// \brief Accessor function to a C-closure bound integer on the C/C++ side
    ///
    /// \param L                    a pointer to the Lua context.
    static int LuaBoolVarAccessor( lua_State *L );

    /// \brief Accessor function to a C-closure bound integer on the C/C++ side
    ///
    /// \param L                    a pointer to the Lua context.
    static int LuaDoubleVarAccessor( lua_State *L );

    /// \brief Accessor function to a C-closure bound wxString on the C++ side
    ///
    /// \param L                    a pointer to the Lua context.
    static int LuaStringVarAccessor( lua_State *L );


  protected:
    wxEvtHandler *m_poParent;    ///< Pointer to the parent event handler (most often the parent window).
    bool *m_pbParentState;       ///< Pointer to the state of the parent object (true == OK, false == not OK).
    lua_State* L;                ///< Lua context.
    wxString m_strScript;        ///< Lua script as a string in memory.
    wxString m_strDomain;        ///< Lua "domain" name (the table where the functions are to register to).

#if __WXLUASCRIPT_DYNAMIC__
  public:
    bool IsOk(){ return m_bOk; } ///< Returns the object state: true on OK and false otherwise.

  protected:
    static wxDynamicLibrary m_oWxLuaScriptDynamicLibrary; ///< ...
    bool m_bOk;                  ///< ...

    // Definition of variables for the corresponding Lua_C functions.
    typedef lua_State* t_luaL_newstate();
    typedef void t_luaL_openlibs( lua_State * );
    typedef lua_CFunction t_lua_atpanic( lua_State *, lua_CFunction );
    typedef int t_lua_error( lua_State * );
    typedef int t_lua_gettop( lua_State * );
    typedef int t_luaL_loadstring( lua_State *, const char * );
    typedef void t_lua_pushstring( lua_State *, const char * );
    typedef void t_lua_pushinteger( lua_State *, lua_Integer );
    typedef void t_lua_pushboolean( lua_State *, int );
    typedef lua_Integer t_lua_tointeger( lua_State *, int ) ;
    typedef const char *t_lua_tolstring (lua_State *, int, size_t * );
    typedef lua_Number t_lua_tonumber( lua_State *, int );
    typedef int t_lua_toboolean( lua_State *, int );
    typedef int t_lua_isnumber( lua_State *, int );
    typedef int t_lua_type( lua_State *, int );
    typedef int t_lua_isstring( lua_State *, int );
    typedef void t_lua_pushcclosure( lua_State *, lua_CFunction, int );
    typedef void t_lua_call( lua_State *, int, int );
    typedef int t_lua_pcall( lua_State *, int, int, int );
    typedef int t_lua_cpcall( lua_State *, lua_CFunction, void * );
    typedef void t_lua_settable( lua_State *, int );
    typedef void t_lua_setfield( lua_State *, int, const char * );
    typedef void t_lua_getfield( lua_State *, int, const char * );
    typedef void t_lua_settop( lua_State *, int );
    typedef void t_lua_insert( lua_State *, int );
    typedef void t_lua_pushvalue( lua_State *, int );
    typedef void t_lua_close( lua_State * );
    typedef void t_lua_createtable( lua_State *, int, int );
    typedef void t_lua_pushlightuserdata( lua_State *, void * );
    typedef const void *t_lua_topointer( lua_State *, int );
    typedef void t_lua_gettable( lua_State *, int );
    typedef void t_lua_pushnumber( lua_State *, lua_Number );

    static t_luaL_newstate *luaL_newstate;
    static t_luaL_openlibs *luaL_openlibs;
    static t_lua_atpanic *lua_atpanic;
    static t_lua_error *lua_error;
    static t_lua_gettop *lua_gettop;
    static t_luaL_loadstring *luaL_loadstring;
    static t_lua_pushstring* lua_pushstring;
    static t_lua_pushinteger* lua_pushinteger;
    static t_lua_pushboolean* lua_pushboolean;
    static t_lua_tointeger* lua_tointeger;
    static t_lua_tolstring* lua_tolstring;
    static t_lua_tonumber* lua_tonumber;
    static t_lua_toboolean* lua_toboolean;
    static t_lua_isnumber* lua_isnumber;
    static t_lua_type* lua_type;
    static t_lua_isstring* lua_isstring;
    static t_lua_pushcclosure* lua_pushcclosure;
    static t_lua_call* lua_call;
    static t_lua_pcall *lua_pcall;
    static t_lua_cpcall *lua_cpcall;
    static t_lua_settable *lua_settable;
    static t_lua_setfield *lua_setfield;
    static t_lua_getfield *lua_getfield;
    static t_lua_settop *lua_settop;
    static t_lua_insert *lua_insert;
    static t_lua_pushvalue *lua_pushvalue;
    static t_lua_close *lua_close;
    static t_lua_createtable *lua_createtable;
    static t_lua_pushlightuserdata *lua_pushlightuserdata;
    static t_lua_topointer *lua_topointer;
    static t_lua_gettable *lua_gettable;
    static t_lua_pushnumber* lua_pushnumber;
#endif // __WXLUASCRIPT_DYNAMIC__
};

#endif // WXLUASCRIPT_H