Lua:

- Removed GetValue() (which has never worked) and deprecated GetStringValue(). The measure value should be returned on Update() now.
- Some related tweaks and cosmetic changes

Library/MeasureScript.cpp

@@ -1,24 +1,50 @@
+/*
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, 
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
 #include "StdAfx.h"
 #include "MeasureScript.h"
 #include "lua/LuaManager.h"
 #include "Litestep.h"
 #include "Rainmeter.h"
 
-const char* g_strInitFunction = "Initialize";
-const char* g_strUpdateFunction = "Update";
-const char* g_strGetValueFunction = "GetValue";
-const char* g_strGetStringValueFunction = "GetStringValue";
+const char* g_InitializeFunctionName = "Initialize";
+const char* g_UpdateFunctionName = "Update";
+const char* g_GetStringFunctionName = "GetStringValue";
 
+/*
+** CMeasureScript
+**
+** The constructor
+**
+*/
 CMeasureScript::CMeasureScript(CMeterWindow* meterWindow, const WCHAR* name) : CMeasure(meterWindow, name),
-	m_pLuaScript(),
-	m_bUpdateDefined(false),
-	m_bGetValueDefined(false),
-	m_bGetStringValueDefined(false),
-	m_bInitializeDefined(false)
+	m_LuaScript(),
+	m_HasInitializeFunction(false),
+	m_HasUpdateFunction(false),
+	m_HasGetStringFunction(false)
 {
 	LuaManager::Init();
 }
 
+/*
+** ~CMeasureScript
+**
+** The destructor
+**
+*/
 CMeasureScript::~CMeasureScript()
 {
 	DeleteLuaScript();
@@ -27,28 +53,39 @@ CMeasureScript::~CMeasureScript()
 
 void CMeasureScript::DeleteLuaScript()
 {
-	if (m_pLuaScript)
+	if (m_LuaScript)
 	{
-		delete m_pLuaScript;
-		m_pLuaScript = NULL;
+		delete m_LuaScript;
+		m_LuaScript = NULL;
 	}
 
-	m_bUpdateDefined = false;
-	m_bGetValueDefined = false;
-	m_bGetStringValueDefined = false;
-	m_bInitializeDefined = false;
+	m_HasInitializeFunction = false;
+	m_HasUpdateFunction = false;
+	m_HasGetStringFunction = false;
 }
 
+/*
+** Initialize
+**
+** Initializes the measure.
+**
+*/
 void CMeasureScript::Initialize()
 {
 	CMeasure::Initialize();
 
-	if (m_bInitializeDefined && m_pLuaScript && m_pLuaScript->IsInitialized())
+	if (m_HasInitializeFunction)
 	{
-		m_pLuaScript->RunFunction(g_strInitFunction);
+		m_LuaScript->RunFunction(g_InitializeFunctionName);
 	}
 }
 
+/*
+** Update
+**
+** Updates the current disk free space value.
+**
+*/
 bool CMeasureScript::Update()
 {
 	if (!CMeasure::PreUpdate())
@@ -56,80 +93,39 @@ bool CMeasureScript::Update()
 		return false;
 	}
 
-	if (m_bUpdateDefined && m_pLuaScript && m_pLuaScript->IsInitialized())
+	if (m_HasUpdateFunction)
 	{
-		m_pLuaScript->RunFunction(g_strUpdateFunction);
+		bool ret = m_LuaScript->RunFunctionWithReturn(g_UpdateFunctionName, m_Value, m_StringValue);
+
+		if (!ret)
+		{
+			// Update() didn't return anything. For backwards compatibility, check for GetStringValue() first
+			if (m_HasGetStringFunction)
+			{
+				m_LuaScript->RunFunctionWithReturn(g_GetStringFunctionName, m_Value, m_StringValue);
+			}
+			else
+			{
+				std::wstring error = L"Script: Update() in measure [";
+				error += m_Name;
+				error += L"] is not returning a valid number or string.";
+				Log(LOG_WARNING, error.c_str());
+			}
+		}
 	}
 
 	return PostUpdate();
 }
 
-double CMeasureScript::GetValue()
-{
-	if (m_bGetValueDefined && m_pLuaScript && m_pLuaScript->IsInitialized())
-	{
-		return m_pLuaScript->RunFunctionDouble(g_strGetValueFunction);
-	}
-
-	return CMeasure::GetValue();
-}
-
-void CMeasureScript::SetValue(double d)
-{
-	m_Value = d;
-}
-
 /*
 ** GetStringValue
 **
-** This method returns the value as text string. The actual value is
-** get with GetValue() so we don't have to worry about m_Invert.
+** Returns the time as string.
 **
-** autoScale  If true, scale the value automatically to some sensible range.
-** scale      The scale to use if autoScale is false.
-** decimals   Number of decimals used in the value.
-** percentual Return the value as % from the maximum value.
 */
 const WCHAR* CMeasureScript::GetStringValue(AUTOSCALE autoScale, double scale, int decimals, bool percentual)
 {
-	if (m_bGetStringValueDefined && m_pLuaScript && m_pLuaScript->IsInitialized())
-	{
-		m_strValue = m_pLuaScript->RunFunctionString(g_strGetStringValueFunction);
-
-		return CheckSubstitute(m_strValue.c_str());
-	}
-
-	return CMeasure::GetStringValue(autoScale, scale, decimals, percentual);
-}
-
-static void stackDump(lua_State *L)
-{
-	int i = lua_gettop(L);
-	LuaManager::LuaLog(LOG_DEBUG, " ----------------  Stack Dump ----------------" );
-	while (i)
-	{
-		int t = lua_type(L, i);
-		switch (t)
-		{
-		case LUA_TSTRING:
-			LuaManager::LuaLog(LOG_DEBUG, "%d:`%s'", i, lua_tostring(L, i));
-			break;
-
-		case LUA_TBOOLEAN:
-			LuaManager::LuaLog(LOG_DEBUG, "%d: %s",i,lua_toboolean(L, i) ? "true" : "false");
-			break;
-
-		case LUA_TNUMBER:
-			LuaManager::LuaLog(LOG_DEBUG, "%d: %g",  i, lua_tonumber(L, i));
-			break;
-
-		default:
-			LuaManager::LuaLog(LOG_DEBUG, "%d: %s", i, lua_typename(L, t));
-			break;
-		}
-		i--;
-	}
-	LuaManager::LuaLog(LOG_DEBUG, "--------------- Stack Dump Finished ---------------" );
+	return m_StringValue.c_str();
 }
 
 /*
@@ -156,16 +152,23 @@ void CMeasureScript::ReadConfig(CConfigParser& parser, const WCHAR* section)
 			lua_State* L = LuaManager::GetState();
 
 			DeleteLuaScript();
-			m_pLuaScript = new LuaScript(LuaManager::GetState(), m_ScriptFile.c_str());
+			m_LuaScript = new LuaScript(LuaManager::GetState(), m_ScriptFile.c_str());
 
-			if (m_pLuaScript->IsInitialized())
+			if (m_LuaScript->IsInitialized())
 			{
-				m_bUpdateDefined = m_pLuaScript->FunctionExists(g_strUpdateFunction);
-				m_bInitializeDefined = m_pLuaScript->FunctionExists(g_strInitFunction);
-				m_bGetValueDefined = m_pLuaScript->FunctionExists(g_strGetValueFunction);
-				m_bGetStringValueDefined = m_pLuaScript->FunctionExists(g_strGetStringValueFunction);
+				m_HasInitializeFunction = m_LuaScript->IsFunction(g_InitializeFunctionName);
+				m_HasUpdateFunction = m_LuaScript->IsFunction(g_UpdateFunctionName);
+				m_HasGetStringFunction = m_LuaScript->IsFunction(g_GetStringFunctionName);  // For backwards compatbility
 
-				m_pLuaScript->PushTable();
+				if (m_HasGetStringFunction)
+				{
+					std::wstring error = L"Script: GetStringValue() used in measure [";
+					error += m_Name;
+					error += L"] has been deprecated. Check manual to ensure future compatibility.";
+					Log(LOG_WARNING, error.c_str());
+				}
+
+				m_LuaScript->PushTable();
 
 				// Push the variable name we want to put a value in.
 				lua_pushstring(L, "SELF");
@@ -174,21 +177,15 @@ void CMeasureScript::ReadConfig(CConfigParser& parser, const WCHAR* section)
 				// Bind the variable
 				lua_settable(L, -3);
 
-				// Push the variable name we want to put a value in.
 				lua_pushstring(L, "SKIN");
-				// Push the value
 				tolua_pushusertype(L, m_MeterWindow, "CMeterWindow");
-				// Bind the variable
 				lua_settable(L, -3);
 
-				// Push the variable name we want to put a value in.
 				lua_pushstring(L, "RAINMETER");
-				// Push the value
 				tolua_pushusertype(L, m_MeterWindow->GetMainObject(), "CRainmeter");
-				// Bind the variable
 				lua_settable(L, -3);
 
-				// Look i nthe properties table for values to read from the section.
+				// Look in the properties table for values to read from the section.
 				lua_getfield(L, -1, "PROPERTIES");
 				if (lua_isnil(L, -1) == 0)
 				{
@@ -213,6 +210,7 @@ void CMeasureScript::ReadConfig(CConfigParser& parser, const WCHAR* section)
 						}
 					}
 				}
+
 				// Pop PROPERTIES table
 				lua_pop(L, 1);
 
@@ -227,7 +225,11 @@ void CMeasureScript::ReadConfig(CConfigParser& parser, const WCHAR* section)
 	}
 	else
 	{
-		LuaManager::LuaLog(LOG_ERROR, "Script: ScriptFile missing in %s.", m_ANSIName.c_str());
+		std::wstring error = L"Script: ScriptFile= is not valid in measure [";
+		error += m_Name;
+		error += L"].";
+		Log(LOG_WARNING, error.c_str());
+
 		DeleteLuaScript();
 	}
 }
@@ -235,10 +237,10 @@ void CMeasureScript::ReadConfig(CConfigParser& parser, const WCHAR* section)
 void CMeasureScript::RunFunctionWithMeter(const char* p_strFunction, CMeter* p_pMeter)
 {
 	// Get the Lua State
-	lua_State* L = m_pLuaScript->GetState();
+	lua_State* L = m_LuaScript->GetState();
 
 	// Push the script table
-	m_pLuaScript->PushTable();
+	m_LuaScript->PushTable();
 
 	// Push the function onto the stack
 	lua_getfield(L, -1, p_strFunction);
@@ -264,7 +266,7 @@ void CMeasureScript::RunFunctionWithMeter(const char* p_strFunction, CMeter* p_p
 
 void CMeasureScript::MeterMouseEvent(CMeter* p_pMeter, MOUSE p_eMouse)
 {
-	if (m_pLuaScript && m_pLuaScript->IsInitialized())
+	if (m_LuaScript && m_LuaScript->IsInitialized())
 	{
 		switch (p_eMouse)
 		{
@@ -306,3 +308,33 @@ void CMeasureScript::MeterMouseEvent(CMeter* p_pMeter, MOUSE p_eMouse)
 		}
 	}
 }
+
+static void stackDump(lua_State *L)
+{
+	int i = lua_gettop(L);
+	LuaManager::LuaLog(LOG_DEBUG, " ----------------  Stack Dump ----------------" );
+	while (i)
+	{
+		int t = lua_type(L, i);
+		switch (t)
+		{
+		case LUA_TSTRING:
+			LuaManager::LuaLog(LOG_DEBUG, "%d:`%s'", i, lua_tostring(L, i));
+			break;
+
+		case LUA_TBOOLEAN:
+			LuaManager::LuaLog(LOG_DEBUG, "%d: %s",i,lua_toboolean(L, i) ? "true" : "false");
+			break;
+
+		case LUA_TNUMBER:
+			LuaManager::LuaLog(LOG_DEBUG, "%d: %g",  i, lua_tonumber(L, i));
+			break;
+
+		default:
+			LuaManager::LuaLog(LOG_DEBUG, "%d: %s", i, lua_typename(L, t));
+			break;
+		}
+		i--;
+	}
+	LuaManager::LuaLog(LOG_DEBUG, "--------------- Stack Dump Finished ---------------" );
+}

Library/MeasureScript.h

@@ -1,5 +1,21 @@
-#ifndef MEASURESCRIPT_H
-#define MEASURESCRIPT_H
+/*
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, 
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+#ifndef __MEASURESCRIPT_H__
+#define __MEASURESCRIPT_H__
 
 #include "Measure.h"
 #include "lua/LuaScript.h"
@@ -16,35 +32,22 @@ public:
 	virtual bool Update();
 	virtual const WCHAR* GetStringValue(AUTOSCALE autoScale, double scale, int decimals, bool percentual);
 
-	double GetValue();
-	void SetValue(double d);
-
 	void DeleteLuaScript();
 
 	void MeterMouseEvent(CMeter* p_pMeter, MOUSE p_eMouse);
 	void RunFunctionWithMeter(const char* p_strFunction, CMeter* p_pMeter);
 
 protected:
-	LuaScript*	m_pLuaScript;
+	LuaScript* m_LuaScript;
 	
-	bool		m_bUpdateDefined;
-	bool		m_bGetValueDefined;
-	bool		m_bGetStringValueDefined;
-	bool		m_bInitializeDefined;
+	bool m_HasInitializeFunction;
+	bool m_HasUpdateFunction;
+	bool m_HasGetStringFunction;
 
-	std::wstring m_strValue;
+	std::wstring m_StringValue;
 
 	std::string m_ScriptFile;
 	std::string m_TableName;
-
-	/*
-	Sqrat::Table* m_ScriptTable;
-	Sqrat::Function* m_UpdateFunc;
-	Sqrat::Function* m_GetValueFunc;
-	Sqrat::Function* m_GetStringValueFunc;
-	Sqrat::Function* m_InitFunc;
-	Sqrat::Function* m_UpdateTransitionFunc;
-	*/
 };
 
 #endif

Library/lua/LuaManager.cpp

@@ -19,35 +19,33 @@
 #include "../Rainmeter.h"
 
 int LuaManager::c_RefCount = 0;
-lua_State* LuaManager::c_pState = 0;
+lua_State* LuaManager::c_State = 0;
 
 void LuaManager::Init()
 {
-	if (c_pState == NULL)
+	if (c_State == NULL)
 	{
 		// Initialize Lua
-		c_pState = lua_open();
+		c_State = lua_open();
 
 		// Load Lua base libraries
-		luaL_openlibs(c_pState);
+		luaL_openlibs(c_State);
 
 		// Initialize tolua
-		tolua_open(c_pState);
+		tolua_open(c_State);
 
 		// Register custom types and functions
-		RegisterTypes(c_pState);
-
-		tolua_module(c_pState, NULL, 0);
-		tolua_beginmodule(c_pState, NULL);
-		RegisterGlobal(c_pState);
-		RegisterMeasure(c_pState);
-		RegisterGroup(c_pState);
-		RegisterMeasure(c_pState);
-		RegisterMeter(c_pState);
-		RegisterMeterWindow(c_pState);
-		RegisterRainmeter(c_pState);
-		RegisterMeterString(c_pState);
-		tolua_endmodule(c_pState);
+		tolua_module(c_State, NULL, 0);
+		tolua_beginmodule(c_State, NULL);
+		RegisterGlobal(c_State);
+		RegisterMeasure(c_State);
+		RegisterGroup(c_State);
+		RegisterMeasure(c_State);
+		RegisterMeter(c_State);
+		RegisterMeterWindow(c_State);
+		RegisterRainmeter(c_State);
+		RegisterMeterString(c_State);
+		tolua_endmodule(c_State);
 	}
 
 	++c_RefCount;
@@ -60,17 +58,13 @@ void LuaManager::CleanUp()
 		--c_RefCount;
 	}
 
-	if (c_RefCount == 0 && c_pState != NULL)
+	if (c_RefCount == 0 && c_State != NULL)
 	{
-		lua_close(c_pState);
-		c_pState = NULL;
+		lua_close(c_State);
+		c_State = NULL;
 	}
 }
 
-void LuaManager::RegisterTypes(lua_State* L)
-{
-}
-
 void LuaManager::ReportErrors(lua_State* L)
 {
 	LuaLog(LOG_ERROR, "Script: %s", lua_tostring(L, -1));

Library/lua/LuaManager.h

@@ -27,19 +27,16 @@ public:
 	static void Init();
 	static void CleanUp();
 
-	static lua_State* GetState() { return c_pState; }
+	static lua_State* GetState() { return c_State; }
 
-	static void ReportErrors(lua_State * L);
+	static void ReportErrors(lua_State* L);
 	static void LuaLog(int nLevel, const char* format, ... );
 
 protected:
 	static int c_RefCount;
-
-	static lua_State* c_pState;
+	static lua_State* c_State;
 
 private:
-	static void RegisterTypes(lua_State* L);
-
 	static void RegisterGlobal(lua_State* L);
 	static void RegisterRainmeter(lua_State* L);
 	static void RegisterGroup(lua_State* L);

Library/lua/LuaScript.cpp

@@ -1,201 +1,220 @@
+/*
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful, 
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
 #include "../StdAfx.h"
 #include "LuaScript.h"
 #include "LuaManager.h"
 #include "../Rainmeter.h"
 
-LuaScript::LuaScript(lua_State* p_pState, const char* p_strFile) : m_pState(p_pState), m_strFile(_strdup(p_strFile)),
+/*
+** LuaScript
+**
+** The constructor
+**
+*/
+LuaScript::LuaScript(lua_State* state, const char* file) : m_State(state),
 	m_iRef(LUA_NOREF),
-	m_bInitialized(true)
+	m_Initialized(true)
 {
-	int result = luaL_loadfile(m_pState, p_strFile);
+	int result = luaL_loadfile(m_State, file);
 
 	// If the file loaded okay.
 	if (result == 0)
 	{
 		// Create the table this script will reside in
-		lua_newtable(m_pState);
+		lua_newtable(m_State);
 
 		// Create the metatable that will store the global table
-		lua_createtable(m_pState, 0, 1);
+		lua_createtable(m_State, 0, 1);
 
 		// Push the global teble
-		lua_pushvalue(m_pState, LUA_GLOBALSINDEX);
+		lua_pushvalue(m_State, LUA_GLOBALSINDEX);
 
 		// Set the __index of the table to be the global table
-		lua_setfield(m_pState, -2, "__index");
+		lua_setfield(m_State, -2, "__index");
 
 		// Set the metatable for the script's table
-		lua_setmetatable(m_pState, -2);
+		lua_setmetatable(m_State, -2);
 
 		// Put the table into the global table
-		m_iRef = luaL_ref(m_pState, LUA_GLOBALSINDEX);
+		m_iRef = luaL_ref(m_State, LUA_GLOBALSINDEX);
 
 		PushTable();
 
 		// Set the environment for the function to be run in to be the table that
 		// has been created for the script/
-		lua_setfenv(m_pState, -2);
+		lua_setfenv(m_State, -2);
 
 		// Execute the Lua script
-		result = lua_pcall(m_pState, 0, LUA_MULTRET, 0);
+		result = lua_pcall(m_State, 0, LUA_MULTRET, 0);
 
 		if (result)
 		{
-			m_bInitialized = false;
-			LuaManager::LuaLog(LOG_ERROR, "Script: Could not run file: %s", lua_tostring(m_pState, -1));
-			lua_pop(m_pState, 1);
+			m_Initialized = false;
+			LuaManager::LuaLog(LOG_ERROR, "Script: Could not run file: %s", lua_tostring(m_State, -1));
+			lua_pop(m_State, 1);
 
-			luaL_unref(m_pState, LUA_GLOBALSINDEX, m_iRef);
+			luaL_unref(m_State, LUA_GLOBALSINDEX, m_iRef);
 			m_iRef = LUA_NOREF;
 		}
 	}
 	else
 	{
-		m_bInitialized = false;
-		LuaManager::LuaLog(LOG_ERROR, "Script: Could not run file: %s", lua_tostring(m_pState, -1));
-		lua_pop(m_pState, 1);
+		m_Initialized = false;
+		LuaManager::LuaLog(LOG_ERROR, "Script: Could not run file: %s", lua_tostring(m_State, -1));
+		lua_pop(m_State, 1);
 	}
 }
 
-LuaScript::~LuaScript(void)
+/*
+** ~LuaScript
+**
+** The destructor
+**
+*/
+LuaScript::~LuaScript()
 {
-	luaL_unref(m_pState, LUA_GLOBALSINDEX, m_iRef);
-	if (m_strFile) free(m_strFile);
+	luaL_unref(m_State, LUA_GLOBALSINDEX, m_iRef);
 }
 
-void LuaScript::BindVariable(const char* p_strName, void* p_pValue, const char* p_strTypeName)
-{
-	PushTable();
-
-	/*
-	// Push the variable name we want to put a value in.
-	lua_pushstring(m_pState, p_strName);
-	// Push the value
-	tolua_pushusertype(m_pState, p_pValue, p_strTypeName);
-	// Bind the variable
-	lua_settable(m_pState, -3);
-
-	// Pop our table off of the stack
-	lua_pop(m_pState, 1);
-
-	*/
-
-	// Push the variable name we want to put a value in.
-	lua_pushstring(m_pState, "SKIN");
-	// Push the value
-	tolua_pushusertype(m_pState, p_pValue, "CMeterWindow");
-	// Bind the variable
-	lua_settable(m_pState, -3);
-
-	//lua_pop(m_pLuaScript->GetState(), 1);
-}
-
-double LuaScript::RunFunctionDouble(const char* p_strFuncName)
-{
-	double result = -1;
-
-	if (m_bInitialized && p_strFuncName)
-	{
-		// Push our table onto the stack
-		PushTable();
-
-		// Push the function onto the stack
-		lua_getfield(m_pState, -1, p_strFuncName);
-
-		if (lua_pcall(m_pState, 0, 1, 0))
-		{
-			LuaManager::ReportErrors(m_pState);
-		}
-		else
-		{
-			if (!lua_isnumber(m_pState, -1))
-			{
-				LuaManager::LuaLog(LOG_ERROR, "Script: Function '%s' must return a number: %s", p_strFuncName, m_strFile);
-			}
-
-			result = lua_tonumber(m_pState, -1);
-		}
-
-		// Pop both the table and the return value off the stack.
-		lua_pop(m_pState, 2);
-	}
-
-	return result;
-}
-
-std::wstring LuaScript::RunFunctionString(const char* p_strFuncName)
-{
-	std::wstring result;
-
-	if (m_bInitialized && p_strFuncName)
-	{
-		// Push our table onto the stack
-		PushTable();
-
-		// Push the function onto the stack
-		lua_getfield(m_pState, -1, p_strFuncName);
-
-		if (lua_pcall(m_pState, 0, 1, 0))
-		{
-			LuaManager::ReportErrors(m_pState);
-		}
-		else
-		{
-			if (!lua_isstring(m_pState, -1))
-			{
-				LuaManager::LuaLog(LOG_ERROR, "Script: Function '%s' must return a string: %s", p_strFuncName, m_strFile);
-			}
-
-			const char* str = lua_tostring(m_pState, -1);
-			result = ConvertToWide(str);
-		}
-
-		// Pop both the table and the return value off the stack.
-		lua_pop(m_pState, 2);
-	}
-
-	return result;
-}
-
-void LuaScript::RunFunction(const char* p_strFuncName)
-{
-	if (m_bInitialized && p_strFuncName)
-	{
-		// Push our table onto the stack
-		PushTable();
-
-		// Push the function onto the stack
-		lua_getfield(m_pState,-1, p_strFuncName);
-
-		if (lua_pcall(m_pState, 0, 0, 0))
-		{
-			LuaManager::ReportErrors(m_pState);
-		}
-
-		lua_pop(m_pState, 1);
-	}
-}
-
-bool LuaScript::FunctionExists(const char* p_strFuncName)
+/*
+** IsFunction
+**
+** Checks if given function is defined in the script file.
+**
+*/
+bool LuaScript::IsFunction(const char* funcName)
 {
 	bool bExists = false;
 
-	if (m_bInitialized && p_strFuncName)
+	if (m_Initialized && funcName)
 	{
 		// Push our table onto the stack
 		PushTable();
 
 		// Push the function onto the stack
-		lua_getfield(m_pState, -1, p_strFuncName);
+		lua_getfield(m_State, -1, funcName);
 
-		if (lua_isfunction( m_pState, -1))
+		if (lua_isfunction(m_State, -1))
 		{
 			bExists = true;
 		}
 
 		// Pop both the table and the function off the stack.
-		lua_pop(m_pState, 2);
+		lua_pop(m_State, 2);
 	}
 
 	return bExists;
 }
+
+/*
+** RunFunction
+**
+** Runs given function in script file.
+**
+*/
+void LuaScript::RunFunction(const char* funcName)
+{
+	if (m_Initialized)
+	{
+		// Push our table onto the stack
+		PushTable();
+
+		// Push the function onto the stack
+		lua_getfield(m_State, -1, funcName);
+
+		if (lua_pcall(m_State, 0, 0, 0))
+		{
+			LuaManager::ReportErrors(m_State);
+		}
+
+		lua_pop(m_State, 1);
+	}
+}
+
+/*
+** RunFunctionWithReturn
+**
+** Runs given function in script file and stores the retruned number and/or string.
+** Returns true if the executed function returns a valid value.
+**
+*/
+bool LuaScript::RunFunctionWithReturn(const char* funcName, double& numValue, std::wstring& strValue)
+{
+	bool ret = false;
+
+	if (m_Initialized)
+	{
+		// Push our table onto the stack
+		PushTable();
+
+		// Push the function onto the stack
+		lua_getfield(m_State, -1, funcName);
+
+		if (lua_pcall(m_State, 0, 1, 0))
+		{
+			LuaManager::ReportErrors(m_State);
+		}
+		else
+		{
+			if (lua_isstring(m_State, -1))
+			{
+				const char* str = lua_tostring(m_State, -1);
+				strValue = ConvertToWide(str);
+
+				// A number is a string and numerical string (e.g. "10") is a number, so check for it here
+				if (lua_isnumber(m_State, -1))
+				{
+					numValue = lua_tonumber(m_State, -1);
+				}
+
+				ret = true;
+			}
+		}
+
+		lua_pop(m_State, 2);
+	}
+
+	return ret;
+}
+
+//void LuaScript::BindVariable(const char* p_strName, void* p_pValue, const char* p_strTypeName)
+//{
+//	PushTable();
+//
+//	/*
+//	// Push the variable name we want to put a value in.
+//	lua_pushstring(m_State, p_strName);
+//	// Push the value
+//	tolua_pushusertype(m_State, p_pValue, p_strTypeName);
+//	// Bind the variable
+//	lua_settable(m_State, -3);
+//
+//	// Pop our table off of the stack
+//	lua_pop(m_State, 1);
+//
+//	*/
+//
+//	// Push the variable name we want to put a value in.
+//	lua_pushstring(m_State, "SKIN");
+//	// Push the value
+//	tolua_pushusertype(m_State, p_pValue, "CMeterWindow");
+//	// Bind the variable
+//	lua_settable(m_State, -3);
+//
+//	//lua_pop(m_pLuaScript->GetState(), 1);
+//}
+//

Library/lua/LuaScript.h

@@ -1,45 +1,46 @@
-#ifndef LUA_SCRIPT_H
-#define LUA_SCRIPT_H
+/*
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version 2
+  of the License, or (at your option) any later version.
 
-#include <stdio.h>
-#include "string"
+  This program is distributed in the hope that it will be useful, 
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+#ifndef __LUASCRIPT_H__
+#define __LUASCRIPT_H__
 
 #include "lua.hpp"
 
 class LuaScript
 {
 public:
+	LuaScript(lua_State* state, const char* file);
+	~LuaScript();
 	
-	LuaScript(lua_State* p_pState, const char* p_strFile);
+	bool IsInitialized() { return m_Initialized; }
 
-	~LuaScript(void);
+	lua_State* GetState() { return m_State; }
+	void PushTable() { lua_rawgeti(m_State, LUA_GLOBALSINDEX, m_iRef); }
 
-	bool FunctionExists(const char* p_strFuncName);
+	bool IsFunction(const char* funcName);
+	void RunFunction(const char* funcName);
+	bool RunFunctionWithReturn(const char* funcName, double& numValue, std::wstring& strValue);
 
-	void RunFunction(const char* p_strFuncName);
-
-	double RunFunctionDouble(const char* p_strFuncName);
-
-	std::wstring RunFunctionString(const char* p_strFuncName);
-
-	lua_State* GetState() { return m_pState; }
-
-	bool IsInitialized() { return m_bInitialized; }
-
-	void BindVariable(const char* p_strName, void* p_pValue, const char* p_strTypeName);
-
-	void PushTable() { lua_rawgeti(m_pState, LUA_GLOBALSINDEX, m_iRef); }
-
-	static void ReportErrors(lua_State * L);
+	static void ReportErrors(lua_State* L);
 
 protected:
+	lua_State* m_State;
 
-	lua_State* m_pState;
-
-	char* m_strFile;
 	int m_iRef;
-
-	bool m_bInitialized;
+	bool m_Initialized;
 };
 
 #endif

Library/lua/glue/LuaGlobal.cpp

@@ -20,5 +20,3 @@ void LuaManager::RegisterGlobal(lua_State* L)
 	lua_register(L, "print", Global_Log);
 	luaL_register(L, "TO", TO_funcs);	// For backwards compatibility
 }
-
-