chibicitiberiu/rainmeter-studio
1
0
Fork 0
mirror of https://github.com/chibicitiberiu/rainmeter-studio.git synced 2024-02-24 04:33:31 +00:00
Code Issues Releases Wiki Activity

Fixed some Lua related issues.

Browse Source 
Removed some internal functions from exposed functions for Lua.
Code cleanup and optimizing for VC2010.
This commit is contained in:
spx
2011-02-15 13:22:19 +00:00
parent b01465a20a
commit 1ba57f2adf
37 changed files with 754 additions and 1127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Library/lua/LuaManager.cpp
View File

@ -61,7 +61,7 @@ void LuaManager::ReportErrors(lua_State * L)
void LuaManager::LuaLog(int nLevel, const char* format, ... )
{
char buffer[4096];
char* buffer = new char[4096];
va_list args;
va_start( args, format );
@ -69,10 +69,10 @@ void LuaManager::LuaLog(int nLevel, const char* format, ... )
_CrtSetReportMode(_CRT_ASSERT, 0);
errno = 0;
_vsnprintf_s( buffer, _TRUNCATE, format, args );
_vsnprintf_s( buffer, 4096, _TRUNCATE, format, args );
if (errno != 0)
{
_snprintf_s(buffer, _TRUNCATE, "Script: LuaLog internal error: %s", format);
_snprintf_s(buffer, 4096, _TRUNCATE, "Script: LuaLog internal error: %s", format);
}
_set_invalid_parameter_handler(oldHandler);
@ -87,4 +87,6 @@ void LuaManager::LuaLog(int nLevel, const char* format, ... )
LSLog(nLevel, L"Rainmeter", str.c_str());
va_end(args);
delete [] buffer;
}

19
Library/lua/LuaPush.cpp
View File

@ -4,28 +4,19 @@
#include "../Litestep.h"
void push_wstring(lua_State* L, void* value, const char* type)
{
std::string str2 = std::string(ConvertToAscii((const wchar_t*)value));
lua_pushstring(L,str2.c_str());
{
push_wchar(L, (void*)((const std::wstring*)value)->c_str(), type);
}
void push_wchar(lua_State* L, void* value, const char* type)
{
std::string str2 = ConvertToAscii((WCHAR*)value);
std::string str2 = ConvertToAscii((const WCHAR*)value);
lua_pushstring(L,str2.c_str());
}
std::wstring to_wstring(lua_State* L, int arg, void* type)
{
// We have a static wstring here so we can keep a copy of the string
// passed in alive while its being passed around.
// This isn't exactly safe, but we shouldn't really have to worry as
// Rainmeter isn't threaded.
static std::wstring str2 = std::wstring(L"");
str2 = ConvertToWide(lua_tostring(L,arg));
return str2;
return ConvertToWide(lua_tostring(L,arg));
}
const wchar_t* to_wchar (lua_State* L, int arg, void* type)
@ -34,7 +25,7 @@ const wchar_t* to_wchar (lua_State* L, int arg, void* type)
// passed in alive while its being passed around.
// This isn't exactly safe, but we shouldn't really have to worry as
// Rainmeter isn't threaded.
static std::wstring str = std::wstring(L"");
static std::wstring str;
str = ConvertToWide(lua_tostring(L,arg));

8
Library/lua/glue/lua_group.cpp
View File

@ -1,6 +1,6 @@
/*
** Lua binding: group
** Generated automatically by tolua++-1.0.92 on 11/22/10 21:20:13.
** Generated automatically by tolua++-1.0.92 on 02/15/11 03:01:14.
*/
#include "../../StdAfx.h"
@ -33,7 +33,7 @@ static int tolua_group_CGroup_BelongsToGroup00(lua_State* tolua_S)
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CGroup",0,&tolua_err) ||
(tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const std::wstring",0,&tolua_err)) ||
(tolua_isvaluenil(tolua_S,2,&tolua_err) || !is_wstring(tolua_S,2,"const std::wstring",0,&tolua_err)) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
@ -41,12 +41,12 @@ static int tolua_group_CGroup_BelongsToGroup00(lua_State* tolua_S)
#endif
{
CGroup* self = (CGroup*) tolua_tousertype(tolua_S,1,0);
const std::wstring* group = ((const std::wstring*) tolua_tousertype(tolua_S,2,0));
const std::wstring group = ((const std::wstring) to_wstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BelongsToGroup'", NULL);
#endif
{
bool tolua_ret = (bool) self->BelongsToGroup(*group);
bool tolua_ret = (bool) self->BelongsToGroup(group);
tolua_pushboolean(tolua_S,(bool)tolua_ret);
}
}

2
Library/lua/glue/lua_group.h
View File

@ -1,6 +1,6 @@
/*
** Lua binding: group
** Generated automatically by tolua++-1.0.92 on 11/22/10 21:20:13.
** Generated automatically by tolua++-1.0.92 on 02/15/11 03:01:14.
*/
/* Exported function */

101
Library/lua/glue/lua_measure.cpp
View File

@ -1,6 +1,6 @@
/*
** Lua binding: measure
** Generated automatically by tolua++-1.0.92 on 01/19/11 04:59:42.
** Generated automatically by tolua++-1.0.92 on 02/15/11 18:55:46.
*/
#include "../../StdAfx.h"
@ -15,9 +15,6 @@
/* Exported function */
TOLUA_API int tolua_measure_open (lua_State* tolua_S);
#include "../../MeterWindow.h"
#include "../../Litestep.h"
#include "../../Group.h"
#include "../../Measure.h"
#include "../LuaPush.h"
@ -29,34 +26,33 @@ static void tolua_reg_types (lua_State* tolua_S)
tolua_usertype(tolua_S,"WCHAR");
}
/* method: SetName of class CMeasure */
#ifndef TOLUA_DISABLE_tolua_measure_CMeasure_SetName00
static int tolua_measure_CMeasure_SetName00(lua_State* tolua_S)
/* method: GetName of class CMeasure */
#ifndef TOLUA_DISABLE_tolua_measure_CMeasure_GetName00
static int tolua_measure_CMeasure_GetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeasure",0,&tolua_err) ||
!is_wchar(tolua_S,2,"const WCHAR",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeasure* self = (CMeasure*) tolua_tousertype(tolua_S,1,0);
const WCHAR* name = ((const WCHAR*) to_wchar(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetName'", NULL);
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'", NULL);
#endif
{
self->SetName(name);
const WCHAR* tolua_ret = (const WCHAR*) self->GetName();
push_wchar(tolua_S,(void*)tolua_ret,"const WCHAR");
}
}
return 0;
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'SetName'.",&tolua_err);
tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
return 0;
#endif
}
@ -188,38 +184,6 @@ static int tolua_measure_CMeasure_IsDisabled00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetName of class CMeasure */
#ifndef TOLUA_DISABLE_tolua_measure_CMeasure_GetName00
static int tolua_measure_CMeasure_GetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeasure",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeasure* self = (CMeasure*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'", NULL);
#endif
{
const WCHAR* tolua_ret = (const WCHAR*) self->GetName();
push_wchar(tolua_S,(void*)tolua_ret,"const WCHAR");
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: HasDynamicVariables of class CMeasure */
#ifndef TOLUA_DISABLE_tolua_measure_CMeasure_HasDynamicVariables00
static int tolua_measure_CMeasure_HasDynamicVariables00(lua_State* tolua_S)
@ -252,39 +216,6 @@ static int tolua_measure_CMeasure_HasDynamicVariables00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: ExecuteBang of class CMeasure */
#ifndef TOLUA_DISABLE_tolua_measure_CMeasure_ExecuteBang00
static int tolua_measure_CMeasure_ExecuteBang00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeasure",0,&tolua_err) ||
!is_wchar(tolua_S,2,"const WCHAR",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeasure* self = (CMeasure*) tolua_tousertype(tolua_S,1,0);
const WCHAR* args = ((const WCHAR*) to_wchar(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ExecuteBang'", NULL);
#endif
{
self->ExecuteBang(args);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'ExecuteBang'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetValue of class CMeasure */
#ifndef TOLUA_DISABLE_tolua_measure_CMeasure_GetValue00
static int tolua_measure_CMeasure_GetValue00(lua_State* tolua_S)
@ -464,7 +395,7 @@ static int tolua_measure_CMeasure_GetStringValue00(lua_State* tolua_S)
#endif
{
CMeasure* self = (CMeasure*) tolua_tousertype(tolua_S,1,0);
AUTOSCALE autoScale = ((AUTOSCALE) (int) tolua_tonumber(tolua_S,2,0));
AUTOSCALE autoScale = ((AUTOSCALE) (int) tolua_tonumber(tolua_S,2,AUTOSCALE_OFF));
double scale = ((double) tolua_tonumber(tolua_S,3,1.0));
int decimals = ((int) tolua_tonumber(tolua_S,4,0));
bool percentual = ((bool) tolua_toboolean(tolua_S,5,false));
@ -492,16 +423,20 @@ TOLUA_API int tolua_measure_open (lua_State* tolua_S)
tolua_reg_types(tolua_S);
tolua_module(tolua_S,NULL,0);
tolua_beginmodule(tolua_S,NULL);
tolua_constant(tolua_S,"AUTOSCALE_1024",AUTOSCALE_1024);
tolua_constant(tolua_S,"AUTOSCALE_1000",AUTOSCALE_1000);
tolua_constant(tolua_S,"AUTOSCALE_1024K",AUTOSCALE_1024K);
tolua_constant(tolua_S,"AUTOSCALE_1000K",AUTOSCALE_1000K);
tolua_constant(tolua_S,"AUTOSCALE_OFF",AUTOSCALE_OFF);
tolua_constant(tolua_S,"AUTOSCALE_ON",AUTOSCALE_ON);
tolua_cclass(tolua_S,"CMeasure","CMeasure","CGroup",NULL);
tolua_beginmodule(tolua_S,"CMeasure");
tolua_function(tolua_S,"SetName",tolua_measure_CMeasure_SetName00);
tolua_function(tolua_S,"GetName",tolua_measure_CMeasure_GetName00);
tolua_function(tolua_S,"GetANSIName",tolua_measure_CMeasure_GetANSIName00);
tolua_function(tolua_S,"Disable",tolua_measure_CMeasure_Disable00);
tolua_function(tolua_S,"Enable",tolua_measure_CMeasure_Enable00);
tolua_function(tolua_S,"IsDisabled",tolua_measure_CMeasure_IsDisabled00);
tolua_function(tolua_S,"GetName",tolua_measure_CMeasure_GetName00);
tolua_function(tolua_S,"HasDynamicVariables",tolua_measure_CMeasure_HasDynamicVariables00);
tolua_function(tolua_S,"ExecuteBang",tolua_measure_CMeasure_ExecuteBang00);
tolua_function(tolua_S,"GetValue",tolua_measure_CMeasure_GetValue00);
tolua_function(tolua_S,"GetRelativeValue",tolua_measure_CMeasure_GetRelativeValue00);
tolua_function(tolua_S,"GetValueRange",tolua_measure_CMeasure_GetValueRange00);

2
Library/lua/glue/lua_measure.h
View File

@ -1,6 +1,6 @@
/*
** Lua binding: measure
** Generated automatically by tolua++-1.0.92 on 01/19/11 04:59:42.
** Generated automatically by tolua++-1.0.92 on 02/15/11 18:55:46.
*/
/* Exported function */

344
Library/lua/glue/lua_meter.cpp
View File

@ -1,6 +1,6 @@
/*
/*
** Lua binding: meter
** Generated automatically by tolua++-1.0.92 on 11/22/10 21:20:13.
** Generated automatically by tolua++-1.0.92 on 02/15/11 18:55:46.
*/
#include "../../StdAfx.h"
@ -40,37 +40,6 @@ static void tolua_reg_types (lua_State* tolua_S)
tolua_usertype(tolua_S,"WCHAR");
}
/* method: Initialize of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_Initialize00
static int tolua_meter_CMeter_Initialize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeter",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeter* self = (CMeter*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Initialize'", NULL);
#endif
{
self->Initialize();
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'Initialize'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: Update of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_Update00
static int tolua_meter_CMeter_Update00(lua_State* tolua_S)
@ -167,38 +136,6 @@ static int tolua_meter_CMeter_HasDynamicVariables00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetH of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_GetH00
static int tolua_meter_CMeter_GetH00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeter",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeter* self = (CMeter*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetH'", NULL);
#endif
{
int tolua_ret = (int) self->GetH();
tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetH'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetW of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_GetW00
static int tolua_meter_CMeter_GetW00(lua_State* tolua_S)
@ -231,6 +168,38 @@ static int tolua_meter_CMeter_GetW00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetH of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_GetH00
static int tolua_meter_CMeter_GetH00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeter",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeter* self = (CMeter*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetH'", NULL);
#endif
{
int tolua_ret = (int) self->GetH();
tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetH'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetX of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_GetX00
static int tolua_meter_CMeter_GetX00(lua_State* tolua_S)
@ -299,6 +268,72 @@ static int tolua_meter_CMeter_GetY00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetW of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_SetW00
static int tolua_meter_CMeter_SetW00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeter",0,&tolua_err) ||
!tolua_isnumber(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeter* self = (CMeter*) tolua_tousertype(tolua_S,1,0);
int w = ((int) tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetW'", NULL);
#endif
{
self->SetW(w);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'SetW'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetH of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_SetH00
static int tolua_meter_CMeter_SetH00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeter",0,&tolua_err) ||
!tolua_isnumber(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeter* self = (CMeter*) tolua_tousertype(tolua_S,1,0);
int h = ((int) tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetH'", NULL);
#endif
{
self->SetH(h);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'SetH'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetX of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_SetX00
static int tolua_meter_CMeter_SetX00(lua_State* tolua_S)
@ -385,7 +420,7 @@ static int tolua_meter_CMeter_GetToolTipText00(lua_State* tolua_S)
#endif
{
const std::wstring& tolua_ret = (const std::wstring&) self->GetToolTipText();
tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const std::wstring");
push_wstring(tolua_S,(void*)&tolua_ret,"const std::wstring");
}
}
return 1;
@ -397,6 +432,38 @@ static int tolua_meter_CMeter_GetToolTipText00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: HasToolTip of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_HasToolTip00
static int tolua_meter_CMeter_HasToolTip00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeter",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeter* self = (CMeter*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasToolTip'", NULL);
#endif
{
bool tolua_ret = (bool) self->HasToolTip();
tolua_pushboolean(tolua_S,(bool)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'HasToolTip'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetToolTipHidden of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_SetToolTipHidden00
static int tolua_meter_CMeter_SetToolTipHidden00(lua_State* tolua_S)
@ -720,39 +787,6 @@ static int tolua_meter_CMeter_HitTest00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetMouseOver of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_SetMouseOver00
static int tolua_meter_CMeter_SetMouseOver00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeter",0,&tolua_err) ||
!tolua_isboolean(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeter* self = (CMeter*) tolua_tousertype(tolua_S,1,0);
bool over = ((bool) tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMouseOver'", NULL);
#endif
{
self->SetMouseOver(over);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'SetMouseOver'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: IsMouseOver of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_IsMouseOver00
static int tolua_meter_CMeter_IsMouseOver00(lua_State* tolua_S)
@ -785,39 +819,6 @@ static int tolua_meter_CMeter_IsMouseOver00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetName of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_SetName00
static int tolua_meter_CMeter_SetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeter",0,&tolua_err) ||
!is_wchar(tolua_S,2,"const WCHAR",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeter* self = (CMeter*) tolua_tousertype(tolua_S,1,0);
const WCHAR* name = ((const WCHAR*) to_wchar(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetName'", NULL);
#endif
{
self->SetName(name);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'SetName'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetName of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_GetName00
static int tolua_meter_CMeter_GetName00(lua_State* tolua_S)
@ -850,73 +851,6 @@ static int tolua_meter_CMeter_GetName00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetW of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_SetW00
static int tolua_meter_CMeter_SetW00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeter",0,&tolua_err) ||
!tolua_isnumber(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeter* self = (CMeter*) tolua_tousertype(tolua_S,1,0);
int w = ((int) tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetW'", NULL);
#endif
{
self->SetW(w);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'SetW'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetH of class CMeter */
#ifndef TOLUA_DISABLE_tolua_meter_CMeter_SetH00
static int tolua_meter_CMeter_SetH00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeter",0,&tolua_err) ||
!tolua_isnumber(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeter* self = (CMeter*) tolua_tousertype(tolua_S,1,0);
int h = ((int) tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetH'", NULL);
#endif
{
self->SetH(h);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'SetH'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* Open function */
TOLUA_API int tolua_meter_open (lua_State* tolua_S)
{
@ -926,19 +860,19 @@ TOLUA_API int tolua_meter_open (lua_State* tolua_S)
tolua_beginmodule(tolua_S,NULL);
tolua_cclass(tolua_S,"CMeter","CMeter","CGroup",NULL);
tolua_beginmodule(tolua_S,"CMeter");
tolua_function(tolua_S,"Initialize",tolua_meter_CMeter_Initialize00);
tolua_function(tolua_S,"Update",tolua_meter_CMeter_Update00);
tolua_function(tolua_S,"HasActiveTransition",tolua_meter_CMeter_HasActiveTransition00);
tolua_function(tolua_S,"HasDynamicVariables",tolua_meter_CMeter_HasDynamicVariables00);
tolua_function(tolua_S,"GetH",tolua_meter_CMeter_GetH00);
tolua_function(tolua_S,"GetW",tolua_meter_CMeter_GetW00);
tolua_function(tolua_S,"GetH",tolua_meter_CMeter_GetH00);
tolua_function(tolua_S,"GetX",tolua_meter_CMeter_GetX00);
tolua_function(tolua_S,"GetY",tolua_meter_CMeter_GetY00);
tolua_function(tolua_S,"SetX",tolua_meter_CMeter_SetX00);
tolua_function(tolua_S,"SetY",tolua_meter_CMeter_SetY00);
tolua_function(tolua_S,"SetW",tolua_meter_CMeter_SetW00);
tolua_function(tolua_S,"SetH",tolua_meter_CMeter_SetH00);
tolua_function(tolua_S,"SetX",tolua_meter_CMeter_SetX00);
tolua_function(tolua_S,"SetY",tolua_meter_CMeter_SetY00);
tolua_function(tolua_S,"GetToolTipText",tolua_meter_CMeter_GetToolTipText00);
tolua_function(tolua_S,"HasToolTip",tolua_meter_CMeter_HasToolTip00);
tolua_function(tolua_S,"SetToolTipHidden",tolua_meter_CMeter_SetToolTipHidden00);
tolua_function(tolua_S,"UpdateToolTip",tolua_meter_CMeter_UpdateToolTip00);
tolua_function(tolua_S,"HasMouseAction",tolua_meter_CMeter_HasMouseAction00);
@ -949,9 +883,7 @@ TOLUA_API int tolua_meter_open (lua_State* tolua_S)
tolua_function(tolua_S,"IsHidden",tolua_meter_CMeter_IsHidden00);
tolua_function(tolua_S,"GetTransformationMatrix",tolua_meter_CMeter_GetTransformationMatrix00);
tolua_function(tolua_S,"HitTest",tolua_meter_CMeter_HitTest00);
tolua_function(tolua_S,"SetMouseOver",tolua_meter_CMeter_SetMouseOver00);
tolua_function(tolua_S,"IsMouseOver",tolua_meter_CMeter_IsMouseOver00);
tolua_function(tolua_S,"SetName",tolua_meter_CMeter_SetName00);
tolua_function(tolua_S,"GetName",tolua_meter_CMeter_GetName00);
tolua_endmodule(tolua_S);
tolua_endmodule(tolua_S);
@ -965,5 +897,3 @@ TOLUA_API int tolua_meter_open (lua_State* tolua_S)
};
#endif

2
Library/lua/glue/lua_meter.h
View File

@ -1,6 +1,6 @@
/*
** Lua binding: meter
** Generated automatically by tolua++-1.0.92 on 11/28/10 09:57:02.
** Generated automatically by tolua++-1.0.92 on 02/15/11 18:55:46.
*/
/* Exported function */

4
Library/lua/glue/lua_meterimage.cpp
View File

@ -1,8 +1,10 @@
/*
** Lua binding: meter_image
** Generated automatically by tolua++-1.0.92 on 11/28/10 09:56:41.
** Generated automatically by tolua++-1.0.92 on 02/15/11 03:01:12.
*/
#include "../../StdAfx.h"
#ifndef __cplusplus
#include "stdlib.h"
#endif

2
Library/lua/glue/lua_meterimage.h
View File

@ -1,6 +1,6 @@
/*
** Lua binding: meter_image
** Generated automatically by tolua++-1.0.92 on 11/28/10 09:56:41.
** Generated automatically by tolua++-1.0.92 on 02/15/11 03:01:12.
*/
/* Exported function */

36
Library/lua/glue/lua_meterstring.cpp
View File

@ -1,6 +1,6 @@
/*
** Lua binding: meter_string
** Generated automatically by tolua++-1.0.92 on 11/23/10 03:16:44.
** Generated automatically by tolua++-1.0.92 on 02/15/11 03:01:13.
*/
#include "../../StdAfx.h"
@ -60,37 +60,6 @@ static int tolua_meter_string_CMeterString_GetX00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: Initialize of class CMeterString */
#ifndef TOLUA_DISABLE_tolua_meter_string_CMeterString_Initialize00
static int tolua_meter_string_CMeterString_Initialize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeterString",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeterString* self = (CMeterString*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Initialize'", NULL);
#endif
{
self->Initialize();
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'Initialize'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: Update of class CMeterString */
#ifndef TOLUA_DISABLE_tolua_meter_string_CMeterString_Update00
static int tolua_meter_string_CMeterString_Update00(lua_State* tolua_S)
@ -157,7 +126,7 @@ static int tolua_meter_string_CMeterString_SetText00(lua_State* tolua_S)
#endif //#ifndef TOLUA_DISABLE
/* method: SetText of class CMeterString */
/* method: GetRect of class CMeterString */
#ifndef TOLUA_DISABLE_tolua_meter_string_CMeterString_GetRect00
static int tolua_meter_string_CMeterString_GetRect00(lua_State* tolua_S)
{
@ -216,7 +185,6 @@ TOLUA_API int tolua_meter_string_open (lua_State* tolua_S)
tolua_cclass(tolua_S,"CMeterString","CMeterString","CMeter",NULL);
tolua_beginmodule(tolua_S,"CMeterString");
tolua_function(tolua_S,"GetX",tolua_meter_string_CMeterString_GetX00);
tolua_function(tolua_S,"Initialize",tolua_meter_string_CMeterString_Initialize00);
tolua_function(tolua_S,"Update",tolua_meter_string_CMeterString_Update00);
tolua_function(tolua_S,"SetText",tolua_meter_string_CMeterString_SetText00);
tolua_function(tolua_S,"GetRect",tolua_meter_string_CMeterString_GetRect00);

2
Library/lua/glue/lua_meterstring.h
View File

@ -1,6 +1,6 @@
/*
** Lua binding: meter_string
** Generated automatically by tolua++-1.0.92 on 11/23/10 03:16:44.
** Generated automatically by tolua++-1.0.92 on 02/15/11 03:01:13.
*/
/* Exported function */

353
Library/lua/glue/lua_meterwindow.cpp
View File

@ -1,6 +1,6 @@
/*
** Lua binding: meterwindow
** Generated automatically by tolua++-1.0.92 on 11/27/10 18:13:41.
** Generated automatically by tolua++-1.0.92 on 02/15/11 18:55:45.
*/
#include "../../StdAfx.h"
@ -17,7 +17,7 @@ TOLUA_API int tolua_meterwindow_open (lua_State* tolua_S);
#include "../../MeterWindow.h"
#include "../../Rainmeter.h"
//#include "../Litestep.h"
#include "../../Litestep.h"
#include "../LuaPush.h"
/* function to release collected object via destructor */
@ -42,51 +42,15 @@ static int tolua_collect_HWND (lua_State* tolua_S)
/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
tolua_usertype(tolua_S,"CMeasure");
tolua_usertype(tolua_S,"std::wstring");
tolua_usertype(tolua_S,"CGroup");
tolua_usertype(tolua_S,"CMeterWindow");
tolua_usertype(tolua_S,"CMeter");
tolua_usertype(tolua_S,"CMeasure");
tolua_usertype(tolua_S,"HWND");
tolua_usertype(tolua_S,"CRainmeter");
tolua_usertype(tolua_S,"CGroup");
tolua_usertype(tolua_S,"std::wstring");
tolua_usertype(tolua_S,"WCHAR");
}
/* method: RunBang of class CMeterWindow */
#ifndef TOLUA_DISABLE_tolua_meterwindow_CMeterWindow_RunBang00
static int tolua_meterwindow_CMeterWindow_RunBang00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeterWindow",0,&tolua_err) ||
!tolua_isnumber(tolua_S,2,0,&tolua_err) ||
!is_wchar(tolua_S,3,"const WCHAR",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,4,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeterWindow* self = (CMeterWindow*) tolua_tousertype(tolua_S,1,0);
BANGCOMMAND bang = ((BANGCOMMAND) (int) tolua_tonumber(tolua_S,2,0));
const WCHAR* arg = ((const WCHAR*) to_wchar(tolua_S,3,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RunBang'", NULL);
#endif
{
self->RunBang(bang,arg);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'RunBang'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: MoveMeter of class CMeterWindow */
#ifndef TOLUA_DISABLE_tolua_meterwindow_CMeterWindow_MoveMeter00
static int tolua_meterwindow_CMeterWindow_MoveMeter00(lua_State* tolua_S)
@ -229,6 +193,41 @@ static int tolua_meterwindow_CMeterWindow_ToggleMeter00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: UpdateMeter of class CMeterWindow */
#ifndef TOLUA_DISABLE_tolua_meterwindow_CMeterWindow_UpdateMeter00
static int tolua_meterwindow_CMeterWindow_UpdateMeter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeterWindow",0,&tolua_err) ||
!is_wchar(tolua_S,2,"const WCHAR",0,&tolua_err) ||
!tolua_isboolean(tolua_S,3,1,&tolua_err) ||
!tolua_isnoobj(tolua_S,4,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeterWindow* self = (CMeterWindow*) tolua_tousertype(tolua_S,1,0);
const WCHAR* name = ((const WCHAR*) to_wchar(tolua_S,2,0));
bool group = ((bool) tolua_toboolean(tolua_S,3,false));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'UpdateMeter'", NULL);
#endif
{
self->UpdateMeter(name,group);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'UpdateMeter'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: DisableMeasure of class CMeterWindow */
#ifndef TOLUA_DISABLE_tolua_meterwindow_CMeterWindow_DisableMeasure00
static int tolua_meterwindow_CMeterWindow_DisableMeasure00(lua_State* tolua_S)
@ -334,15 +333,15 @@ static int tolua_meterwindow_CMeterWindow_ToggleMeasure00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: Refresh of class CMeterWindow */
#ifndef TOLUA_DISABLE_tolua_meterwindow_CMeterWindow_Refresh00
static int tolua_meterwindow_CMeterWindow_Refresh00(lua_State* tolua_S)
/* method: UpdateMeasure of class CMeterWindow */
#ifndef TOLUA_DISABLE_tolua_meterwindow_CMeterWindow_UpdateMeasure00
static int tolua_meterwindow_CMeterWindow_UpdateMeasure00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeterWindow",0,&tolua_err) ||
!tolua_isboolean(tolua_S,2,0,&tolua_err) ||
!is_wchar(tolua_S,2,"const WCHAR",0,&tolua_err) ||
!tolua_isboolean(tolua_S,3,1,&tolua_err) ||
!tolua_isnoobj(tolua_S,4,&tolua_err)
)
@ -351,19 +350,19 @@ static int tolua_meterwindow_CMeterWindow_Refresh00(lua_State* tolua_S)
#endif
{
CMeterWindow* self = (CMeterWindow*) tolua_tousertype(tolua_S,1,0);
bool init = ((bool) tolua_toboolean(tolua_S,2,0));
bool all = ((bool) tolua_toboolean(tolua_S,3,false));
const WCHAR* name = ((const WCHAR*) to_wchar(tolua_S,2,0));
bool group = ((bool) tolua_toboolean(tolua_S,3,false));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Refresh'", NULL);
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'UpdateMeasure'", NULL);
#endif
{
self->Refresh(init,all);
self->UpdateMeasure(name,group);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'Refresh'.",&tolua_err);
tolua_error(tolua_S,"#ferror in function 'UpdateMeasure'.",&tolua_err);
return 0;
#endif
}
@ -400,39 +399,6 @@ static int tolua_meterwindow_CMeterWindow_Redraw00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetMouseLeaveEvent of class CMeterWindow */
#ifndef TOLUA_DISABLE_tolua_meterwindow_CMeterWindow_SetMouseLeaveEvent00
static int tolua_meterwindow_CMeterWindow_SetMouseLeaveEvent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeterWindow",0,&tolua_err) ||
!tolua_isboolean(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeterWindow* self = (CMeterWindow*) tolua_tousertype(tolua_S,1,0);
bool cancel = ((bool) tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMouseLeaveEvent'", NULL);
#endif
{
self->SetMouseLeaveEvent(cancel);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'SetMouseLeaveEvent'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: MoveWindow of class CMeterWindow */
#ifndef TOLUA_DISABLE_tolua_meterwindow_CMeterWindow_MoveWindow00
static int tolua_meterwindow_CMeterWindow_MoveWindow00(lua_State* tolua_S)
@ -836,6 +802,134 @@ static int tolua_meterwindow_CMeterWindow_GetYFromBottom00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetW of class CMeterWindow */
#ifndef TOLUA_DISABLE_tolua_meterwindow_CMeterWindow_GetW00
static int tolua_meterwindow_CMeterWindow_GetW00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeterWindow",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeterWindow* self = (CMeterWindow*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetW'", NULL);
#endif
{
int tolua_ret = (int) self->GetW();
tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetW'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetH of class CMeterWindow */
#ifndef TOLUA_DISABLE_tolua_meterwindow_CMeterWindow_GetH00
static int tolua_meterwindow_CMeterWindow_GetH00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeterWindow",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeterWindow* self = (CMeterWindow*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetH'", NULL);
#endif
{
int tolua_ret = (int) self->GetH();
tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetH'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetX of class CMeterWindow */
#ifndef TOLUA_DISABLE_tolua_meterwindow_CMeterWindow_GetX00
static int tolua_meterwindow_CMeterWindow_GetX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeterWindow",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeterWindow* self = (CMeterWindow*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetX'", NULL);
#endif
{
int tolua_ret = (int) self->GetX();
tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetX'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetY of class CMeterWindow */
#ifndef TOLUA_DISABLE_tolua_meterwindow_CMeterWindow_GetY00
static int tolua_meterwindow_CMeterWindow_GetY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeterWindow",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CMeterWindow* self = (CMeterWindow*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetY'", NULL);
#endif
{
int tolua_ret = (int) self->GetY();
tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetY'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetXScreenDefined of class CMeterWindow */
#ifndef TOLUA_DISABLE_tolua_meterwindow_CMeterWindow_GetXScreenDefined00
static int tolua_meterwindow_CMeterWindow_GetXScreenDefined00(lua_State* tolua_S)
@ -1324,7 +1418,7 @@ static int tolua_meterwindow_CMeterWindow_MakePathAbsolute00(lua_State* tolua_S)
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeterWindow",0,&tolua_err) ||
(tolua_isvaluenil(tolua_S,2,&tolua_err) || !is_wstring(tolua_S,2,"std::wstring",0,&tolua_err)) ||
(tolua_isvaluenil(tolua_S,2,&tolua_err) || !is_wstring(tolua_S,2,"const std::wstring",0,&tolua_err)) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
@ -1332,7 +1426,7 @@ static int tolua_meterwindow_CMeterWindow_MakePathAbsolute00(lua_State* tolua_S)
#endif
{
CMeterWindow* self = (CMeterWindow*) tolua_tousertype(tolua_S,1,0);
std::wstring path = to_wstring(tolua_S,2,0);
const std::wstring path = ((const std::wstring) to_wstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MakePathAbsolute'", NULL);
#endif
@ -1342,9 +1436,7 @@ static int tolua_meterwindow_CMeterWindow_MakePathAbsolute00(lua_State* tolua_S)
#ifdef __cplusplus
push_wstring(tolua_S,(void*)&tolua_ret,"std::wstring");
#else
void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::wstring));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
push_wstring(tolua_S,(void*)&tolua_ret,"std::wstring");
#endif
}
}
@ -1366,7 +1458,7 @@ static int tolua_meterwindow_CMeterWindow_GetMeter00(lua_State* tolua_S)
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeterWindow",0,&tolua_err) ||
(tolua_isvaluenil(tolua_S,2,&tolua_err) || !is_wstring(tolua_S,2,"std::wstring",0,&tolua_err)) ||
(tolua_isvaluenil(tolua_S,2,&tolua_err) || !is_wstring(tolua_S,2,"const std::wstring",0,&tolua_err)) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
@ -1374,7 +1466,7 @@ static int tolua_meterwindow_CMeterWindow_GetMeter00(lua_State* tolua_S)
#endif
{
CMeterWindow* self = (CMeterWindow*) tolua_tousertype(tolua_S,1,0);
std::wstring meterName = to_wstring(tolua_S,2,0);
const std::wstring meterName = ((const std::wstring) to_wstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMeter'", NULL);
#endif
@ -1400,7 +1492,7 @@ static int tolua_meterwindow_CMeterWindow_GetMeasure00(lua_State* tolua_S)
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CMeterWindow",0,&tolua_err) ||
(tolua_isvaluenil(tolua_S,2,&tolua_err) || !is_wstring(tolua_S,2,"std::wstring",0,&tolua_err)) ||
(tolua_isvaluenil(tolua_S,2,&tolua_err) || !is_wstring(tolua_S,2,"const std::wstring",0,&tolua_err)) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
@ -1408,7 +1500,7 @@ static int tolua_meterwindow_CMeterWindow_GetMeasure00(lua_State* tolua_S)
#endif
{
CMeterWindow* self = (CMeterWindow*) tolua_tousertype(tolua_S,1,0);
std::wstring measureName = to_wstring(tolua_S,2,0);
const std::wstring measureName = ((const std::wstring) to_wstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMeasure'", NULL);
#endif
@ -1447,7 +1539,7 @@ static int tolua_meterwindow_CMeterWindow_ReplaceVariables00(lua_State* tolua_S)
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReplaceVariables'", NULL);
#endif
{
const char* tolua_ret = self->ReplaceVariables(p_str);
const char* tolua_ret = (const char*) self->ReplaceVariables(p_str);
tolua_pushstring(tolua_S,(const char*)tolua_ret);
}
}
@ -1502,93 +1594,27 @@ TOLUA_API int tolua_meterwindow_open (lua_State* tolua_S)
tolua_reg_types(tolua_S);
tolua_module(tolua_S,NULL,0);
tolua_beginmodule(tolua_S,NULL);
tolua_constant(tolua_S,"WM_DELAYED_EXECUTE",WM_DELAYED_EXECUTE);
tolua_constant(tolua_S,"WM_DELAYED_REFRESH",WM_DELAYED_REFRESH);
tolua_constant(tolua_S,"WM_DELAYED_MOVE",WM_DELAYED_MOVE);
tolua_constant(tolua_S,"MOUSE_LMB_DOWN",MOUSE_LMB_DOWN);
tolua_constant(tolua_S,"MOUSE_LMB_UP",MOUSE_LMB_UP);
tolua_constant(tolua_S,"MOUSE_LMB_DBLCLK",MOUSE_LMB_DBLCLK);
tolua_constant(tolua_S,"MOUSE_RMB_DOWN",MOUSE_RMB_DOWN);
tolua_constant(tolua_S,"MOUSE_RMB_UP",MOUSE_RMB_UP);
tolua_constant(tolua_S,"MOUSE_RMB_DBLCLK",MOUSE_RMB_DBLCLK);
tolua_constant(tolua_S,"MOUSE_MMB_DOWN",MOUSE_MMB_DOWN);
tolua_constant(tolua_S,"MOUSE_MMB_UP",MOUSE_MMB_UP);
tolua_constant(tolua_S,"MOUSE_MMB_DBLCLK",MOUSE_MMB_DBLCLK);
tolua_constant(tolua_S,"MOUSE_OVER",MOUSE_OVER);
tolua_constant(tolua_S,"MOUSE_LEAVE",MOUSE_LEAVE);
tolua_constant(tolua_S,"BUTTONPROC_DOWN",BUTTONPROC_DOWN);
tolua_constant(tolua_S,"BUTTONPROC_UP",BUTTONPROC_UP);
tolua_constant(tolua_S,"BUTTONPROC_MOVE",BUTTONPROC_MOVE);
tolua_constant(tolua_S,"ZPOSITION_ONDESKTOP",ZPOSITION_ONDESKTOP);
tolua_constant(tolua_S,"ZPOSITION_ONBOTTOM",ZPOSITION_ONBOTTOM);
tolua_constant(tolua_S,"ZPOSITION_NORMAL",ZPOSITION_NORMAL);
tolua_constant(tolua_S,"ZPOSITION_ONTOP",ZPOSITION_ONTOP);
tolua_constant(tolua_S,"ZPOSITION_ONTOPMOST",ZPOSITION_ONTOPMOST);
tolua_constant(tolua_S,"BGMODE_IMAGE",BGMODE_IMAGE);
tolua_constant(tolua_S,"BGMODE_COPY",BGMODE_COPY);
tolua_constant(tolua_S,"BGMODE_SOLID",BGMODE_SOLID);
tolua_constant(tolua_S,"BGMODE_SCALED_IMAGE",BGMODE_SCALED_IMAGE);
tolua_constant(tolua_S,"HIDEMODE_NONE",HIDEMODE_NONE);
tolua_constant(tolua_S,"HIDEMODE_HIDE",HIDEMODE_HIDE);
tolua_constant(tolua_S,"HIDEMODE_FADEIN",HIDEMODE_FADEIN);
tolua_constant(tolua_S,"HIDEMODE_FADEOUT",HIDEMODE_FADEOUT);
tolua_constant(tolua_S,"BEVELTYPE_NONE",BEVELTYPE_NONE);
tolua_constant(tolua_S,"BEVELTYPE_UP",BEVELTYPE_UP);
tolua_constant(tolua_S,"BEVELTYPE_DOWN",BEVELTYPE_DOWN);
tolua_constant(tolua_S,"BANG_REFRESH",BANG_REFRESH);
tolua_constant(tolua_S,"BANG_REDRAW",BANG_REDRAW);
tolua_constant(tolua_S,"BANG_TOGGLEMETER",BANG_TOGGLEMETER);
tolua_constant(tolua_S,"BANG_SHOWMETER",BANG_SHOWMETER);
tolua_constant(tolua_S,"BANG_HIDEMETER",BANG_HIDEMETER);
tolua_constant(tolua_S,"BANG_MOVEMETER",BANG_MOVEMETER);
tolua_constant(tolua_S,"BANG_TOGGLEMEASURE",BANG_TOGGLEMEASURE);
tolua_constant(tolua_S,"BANG_ENABLEMEASURE",BANG_ENABLEMEASURE);
tolua_constant(tolua_S,"BANG_DISABLEMEASURE",BANG_DISABLEMEASURE);
tolua_constant(tolua_S,"BANG_SHOW",BANG_SHOW);
tolua_constant(tolua_S,"BANG_HIDE",BANG_HIDE);
tolua_constant(tolua_S,"BANG_TOGGLE",BANG_TOGGLE);
tolua_constant(tolua_S,"BANG_SHOWFADE",BANG_SHOWFADE);
tolua_constant(tolua_S,"BANG_HIDEFADE",BANG_HIDEFADE);
tolua_constant(tolua_S,"BANG_TOGGLEFADE",BANG_TOGGLEFADE);
tolua_constant(tolua_S,"BANG_MOVE",BANG_MOVE);
tolua_constant(tolua_S,"BANG_ZPOS",BANG_ZPOS);
tolua_constant(tolua_S,"BANG_SETTRANSPARENCY",BANG_SETTRANSPARENCY);
tolua_constant(tolua_S,"BANG_CLICKTHROUGH",BANG_CLICKTHROUGH);
tolua_constant(tolua_S,"BANG_DRAGGABLE",BANG_DRAGGABLE);
tolua_constant(tolua_S,"BANG_SNAPEDGES",BANG_SNAPEDGES);
tolua_constant(tolua_S,"BANG_KEEPONSCREEN",BANG_KEEPONSCREEN);
tolua_constant(tolua_S,"BANG_TOGGLEMETERGROUP",BANG_TOGGLEMETERGROUP);
tolua_constant(tolua_S,"BANG_SHOWMETERGROUP",BANG_SHOWMETERGROUP);
tolua_constant(tolua_S,"BANG_HIDEMETERGROUP",BANG_HIDEMETERGROUP);
tolua_constant(tolua_S,"BANG_TOGGLEMEASUREGROUP",BANG_TOGGLEMEASUREGROUP);
tolua_constant(tolua_S,"BANG_ENABLEMEASUREGROUP",BANG_ENABLEMEASUREGROUP);
tolua_constant(tolua_S,"BANG_DISABLEMEASUREGROUP",BANG_DISABLEMEASUREGROUP);
tolua_constant(tolua_S,"BANG_LSHOOK",BANG_LSHOOK);
tolua_constant(tolua_S,"BANG_PLUGIN",BANG_PLUGIN);
tolua_constant(tolua_S,"BANG_SETVARIABLE",BANG_SETVARIABLE);
tolua_cclass(tolua_S,"CRainmeter","CRainmeter","",NULL);
tolua_beginmodule(tolua_S,"CRainmeter");
tolua_endmodule(tolua_S);
tolua_cclass(tolua_S,"CMeasure","CMeasure","",NULL);
tolua_beginmodule(tolua_S,"CMeasure");
tolua_endmodule(tolua_S);
tolua_cclass(tolua_S,"CMeter","CMeter","",NULL);
tolua_beginmodule(tolua_S,"CMeter");
tolua_endmodule(tolua_S);
tolua_cclass(tolua_S,"CMeterWindow","CMeterWindow","CGroup",NULL);
tolua_beginmodule(tolua_S,"CMeterWindow");
tolua_function(tolua_S,"Bang", tolua_meterwindow_CMeterWindow_Bang00);
tolua_function(tolua_S,"RunBang",tolua_meterwindow_CMeterWindow_RunBang00);
tolua_function(tolua_S,"MoveMeter",tolua_meterwindow_CMeterWindow_MoveMeter00);
tolua_function(tolua_S,"HideMeter",tolua_meterwindow_CMeterWindow_HideMeter00);
tolua_function(tolua_S,"ShowMeter",tolua_meterwindow_CMeterWindow_ShowMeter00);
tolua_function(tolua_S,"ToggleMeter",tolua_meterwindow_CMeterWindow_ToggleMeter00);
tolua_function(tolua_S,"UpdateMeter",tolua_meterwindow_CMeterWindow_UpdateMeter00);
tolua_function(tolua_S,"DisableMeasure",tolua_meterwindow_CMeterWindow_DisableMeasure00);
tolua_function(tolua_S,"EnableMeasure",tolua_meterwindow_CMeterWindow_EnableMeasure00);
tolua_function(tolua_S,"ToggleMeasure",tolua_meterwindow_CMeterWindow_ToggleMeasure00);
tolua_function(tolua_S,"Refresh",tolua_meterwindow_CMeterWindow_Refresh00);
tolua_function(tolua_S,"UpdateMeasure",tolua_meterwindow_CMeterWindow_UpdateMeasure00);
tolua_function(tolua_S,"Redraw",tolua_meterwindow_CMeterWindow_Redraw00);
tolua_function(tolua_S,"SetMouseLeaveEvent",tolua_meterwindow_CMeterWindow_SetMouseLeaveEvent00);
tolua_function(tolua_S,"MoveWindow",tolua_meterwindow_CMeterWindow_MoveWindow00);
tolua_function(tolua_S,"ChangeZPos",tolua_meterwindow_CMeterWindow_ChangeZPos00);
tolua_function(tolua_S,"FadeWindow",tolua_meterwindow_CMeterWindow_FadeWindow00);
@ -1601,6 +1627,10 @@ TOLUA_API int tolua_meterwindow_open (lua_State* tolua_S)
tolua_function(tolua_S,"GetYPercentage",tolua_meterwindow_CMeterWindow_GetYPercentage00);
tolua_function(tolua_S,"GetXFromRight",tolua_meterwindow_CMeterWindow_GetXFromRight00);
tolua_function(tolua_S,"GetYFromBottom",tolua_meterwindow_CMeterWindow_GetYFromBottom00);
tolua_function(tolua_S,"GetW",tolua_meterwindow_CMeterWindow_GetW00);
tolua_function(tolua_S,"GetH",tolua_meterwindow_CMeterWindow_GetH00);
tolua_function(tolua_S,"GetX",tolua_meterwindow_CMeterWindow_GetX00);
tolua_function(tolua_S,"GetY",tolua_meterwindow_CMeterWindow_GetY00);
tolua_function(tolua_S,"GetXScreenDefined",tolua_meterwindow_CMeterWindow_GetXScreenDefined00);
tolua_function(tolua_S,"GetYScreenDefined",tolua_meterwindow_CMeterWindow_GetYScreenDefined00);
tolua_function(tolua_S,"GetXScreen",tolua_meterwindow_CMeterWindow_GetXScreen00);
@ -1620,6 +1650,7 @@ TOLUA_API int tolua_meterwindow_open (lua_State* tolua_S)
tolua_function(tolua_S,"GetMeter",tolua_meterwindow_CMeterWindow_GetMeter00);
tolua_function(tolua_S,"GetMeasure",tolua_meterwindow_CMeterWindow_GetMeasure00);
tolua_function(tolua_S,"ReplaceVariables",tolua_meterwindow_CMeterWindow_ReplaceVariables00);
tolua_function(tolua_S,"Bang", tolua_meterwindow_CMeterWindow_Bang00);
tolua_endmodule(tolua_S);
tolua_endmodule(tolua_S);
return 1;

2
Library/lua/glue/lua_meterwindow.h
View File

@ -1,6 +1,6 @@
/*
** Lua binding: meterwindow
** Generated automatically by tolua++-1.0.92 on 11/27/10 18:13:41.
** Generated automatically by tolua++-1.0.92 on 02/15/11 18:55:45.
*/
/* Exported function */

527
Library/lua/glue/lua_rainmeter.cpp
View File

@ -1,6 +1,6 @@
/*
** Lua binding: rainmeter
** Generated automatically by tolua++-1.0.92 on 11/23/10 01:56:47.
** Generated automatically by tolua++-1.0.92 on 02/15/11 21:07:15.
*/
#include "../../StdAfx.h"
@ -41,46 +41,11 @@ static int tolua_collect_BOOL (lua_State* tolua_S)
static void tolua_reg_types (lua_State* tolua_S)
{
tolua_usertype(tolua_S,"std::wstring");
tolua_usertype(tolua_S,"CMeterWindow");
tolua_usertype(tolua_S,"BOOL");
tolua_usertype(tolua_S,"CTrayWindow");
tolua_usertype(tolua_S,"CRainmeter");
tolua_usertype(tolua_S,"CMeterWindow");
tolua_usertype(tolua_S,"POINT");
tolua_usertype(tolua_S,"WCHAR");
}
/* method: GetTrayWindow of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_GetTrayWindow00
static int tolua_rainmeter_CRainmeter_GetTrayWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CRainmeter",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CRainmeter* self = (CRainmeter*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTrayWindow'", NULL);
#endif
{
CTrayWindow* tolua_ret = (CTrayWindow*) self->GetTrayWindow();
tolua_pushusertype(tolua_S,(void*)tolua_ret,"CTrayWindow");
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetTrayWindow'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetMeterWindow of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_GetMeterWindow00
static int tolua_rainmeter_CRainmeter_GetMeterWindow00(lua_State* tolua_S)
@ -97,7 +62,7 @@ static int tolua_rainmeter_CRainmeter_GetMeterWindow00(lua_State* tolua_S)
#endif
{
CRainmeter* self = (CRainmeter*) tolua_tousertype(tolua_S,1,0);
const std::wstring config = to_wstring(tolua_S,2,0);
const std::wstring config = ((const std::wstring) to_wstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMeterWindow'", NULL);
#endif
@ -275,6 +240,38 @@ static int tolua_rainmeter_CRainmeter_GetPluginPath00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetAddonPath of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_GetAddonPath00
static int tolua_rainmeter_CRainmeter_GetAddonPath00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CRainmeter",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CRainmeter* self = (CRainmeter*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetAddonPath'", NULL);
#endif
{
const std::wstring& tolua_ret = (const std::wstring&) self->GetAddonPath();
push_wstring(tolua_S,(void*)&tolua_ret,"const std::wstring");
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetAddonPath'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetSettingsPath of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_GetSettingsPath00
static int tolua_rainmeter_CRainmeter_GetSettingsPath00(lua_State* tolua_S)
@ -297,13 +294,9 @@ static int tolua_rainmeter_CRainmeter_GetSettingsPath00(lua_State* tolua_S)
std::wstring tolua_ret = (std::wstring) self->GetSettingsPath();
{
#ifdef __cplusplus
void* tolua_obj = Mtolua_new((std::wstring)(tolua_ret));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
push_wstring(tolua_S,(void*)&tolua_ret,"std::wstring");
#else
void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::wstring));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
push_wstring(tolua_S,(void*)&tolua_ret,"std::wstring");
#endif
}
}
@ -441,37 +434,6 @@ static int tolua_rainmeter_CRainmeter_GetDebug00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: ReloadSettings of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_ReloadSettings00
static int tolua_rainmeter_CRainmeter_ReloadSettings00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CRainmeter",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CRainmeter* self = (CRainmeter*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReloadSettings'", NULL);
#endif
{
self->ReloadSettings();
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'ReloadSettings'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: SaveSettings of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_SaveSettings00
static int tolua_rainmeter_CRainmeter_SaveSettings00(lua_State* tolua_S)
@ -503,37 +465,6 @@ static int tolua_rainmeter_CRainmeter_SaveSettings00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: ReadStats of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_ReadStats00
static int tolua_rainmeter_CRainmeter_ReadStats00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CRainmeter",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CRainmeter* self = (CRainmeter*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReadStats'", NULL);
#endif
{
self->ReadStats();
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'ReadStats'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: WriteStats of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_WriteStats00
static int tolua_rainmeter_CRainmeter_WriteStats00(lua_State* tolua_S)
@ -723,6 +654,103 @@ static int tolua_rainmeter_CRainmeter_DeleteLogFile00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetDisableRDP of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_GetDisableRDP00
static int tolua_rainmeter_CRainmeter_GetDisableRDP00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CRainmeter",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CRainmeter* self = (CRainmeter*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDisableRDP'", NULL);
#endif
{
bool tolua_ret = (bool) self->GetDisableRDP();
tolua_pushboolean(tolua_S,(bool)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetDisableRDP'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetDisableDragging of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_GetDisableDragging00
static int tolua_rainmeter_CRainmeter_GetDisableDragging00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CRainmeter",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CRainmeter* self = (CRainmeter*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDisableDragging'", NULL);
#endif
{
bool tolua_ret = (bool) self->GetDisableDragging();
tolua_pushboolean(tolua_S,(bool)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetDisableDragging'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetDisableDragging of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_SetDisableDragging00
static int tolua_rainmeter_CRainmeter_SetDisableDragging00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CRainmeter",0,&tolua_err) ||
!tolua_isboolean(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CRainmeter* self = (CRainmeter*) tolua_tousertype(tolua_S,1,0);
bool dragging = ((bool) tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetDisableDragging'", NULL);
#endif
{
self->SetDisableDragging(dragging);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'SetDisableDragging'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetDebug of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_SetDebug00
static int tolua_rainmeter_CRainmeter_SetDebug00(lua_State* tolua_S)
@ -842,18 +870,8 @@ static int tolua_rainmeter_CRainmeter_GetTrayExecuteL00(lua_State* tolua_S)
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTrayExecuteL'", NULL);
#endif
{
std::wstring tolua_ret = (std::wstring) self->GetTrayExecuteL();
{
#ifdef __cplusplus
void* tolua_obj = Mtolua_new((std::wstring)(tolua_ret));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::wstring));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
}
const std::wstring& tolua_ret = (const std::wstring&) self->GetTrayExecuteL();
push_wstring(tolua_S,(void*)&tolua_ret,"const std::wstring");
}
}
return 1;
@ -884,18 +902,8 @@ static int tolua_rainmeter_CRainmeter_GetTrayExecuteR00(lua_State* tolua_S)
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTrayExecuteR'", NULL);
#endif
{
std::wstring tolua_ret = (std::wstring) self->GetTrayExecuteR();
{
#ifdef __cplusplus
void* tolua_obj = Mtolua_new((std::wstring)(tolua_ret));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::wstring));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
}
const std::wstring& tolua_ret = (const std::wstring&) self->GetTrayExecuteR();
push_wstring(tolua_S,(void*)&tolua_ret,"const std::wstring");
}
}
return 1;
@ -926,18 +934,8 @@ static int tolua_rainmeter_CRainmeter_GetTrayExecuteM00(lua_State* tolua_S)
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTrayExecuteM'", NULL);
#endif
{
std::wstring tolua_ret = (std::wstring) self->GetTrayExecuteM();
{
#ifdef __cplusplus
void* tolua_obj = Mtolua_new((std::wstring)(tolua_ret));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::wstring));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
}
const std::wstring& tolua_ret = (const std::wstring&) self->GetTrayExecuteM();
push_wstring(tolua_S,(void*)&tolua_ret,"const std::wstring");
}
}
return 1;
@ -968,18 +966,8 @@ static int tolua_rainmeter_CRainmeter_GetTrayExecuteDR00(lua_State* tolua_S)
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTrayExecuteDR'", NULL);
#endif
{
std::wstring tolua_ret = (std::wstring) self->GetTrayExecuteDR();
{
#ifdef __cplusplus
void* tolua_obj = Mtolua_new((std::wstring)(tolua_ret));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::wstring));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
}
const std::wstring& tolua_ret = (const std::wstring&) self->GetTrayExecuteDR();
push_wstring(tolua_S,(void*)&tolua_ret,"const std::wstring");
}
}
return 1;
@ -1010,18 +998,8 @@ static int tolua_rainmeter_CRainmeter_GetTrayExecuteDL00(lua_State* tolua_S)
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTrayExecuteDL'", NULL);
#endif
{
std::wstring tolua_ret = (std::wstring) self->GetTrayExecuteDL();
{
#ifdef __cplusplus
void* tolua_obj = Mtolua_new((std::wstring)(tolua_ret));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::wstring));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
}
const std::wstring& tolua_ret = (const std::wstring&) self->GetTrayExecuteDL();
push_wstring(tolua_S,(void*)&tolua_ret,"const std::wstring");
}
}
return 1;
@ -1052,18 +1030,8 @@ static int tolua_rainmeter_CRainmeter_GetTrayExecuteDM00(lua_State* tolua_S)
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTrayExecuteDM'", NULL);
#endif
{
std::wstring tolua_ret = (std::wstring) self->GetTrayExecuteDM();
{
#ifdef __cplusplus
void* tolua_obj = Mtolua_new((std::wstring)(tolua_ret));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::wstring));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
}
const std::wstring& tolua_ret = (const std::wstring&) self->GetTrayExecuteDM();
push_wstring(tolua_S,(void*)&tolua_ret,"const std::wstring");
}
}
return 1;
@ -1075,197 +1043,6 @@ static int tolua_rainmeter_CRainmeter_GetTrayExecuteDM00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: ExecuteBang of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_ExecuteBang00
static int tolua_rainmeter_CRainmeter_ExecuteBang00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CRainmeter",0,&tolua_err) ||
(tolua_isvaluenil(tolua_S,2,&tolua_err) || !is_wstring(tolua_S,2,"const std::wstring",0,&tolua_err)) ||
(tolua_isvaluenil(tolua_S,3,&tolua_err) || !is_wstring(tolua_S,3,"const std::wstring",0,&tolua_err)) ||
!tolua_isusertype(tolua_S,4,"CMeterWindow",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,5,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CRainmeter* self = (CRainmeter*) tolua_tousertype(tolua_S,1,0);
const std::wstring* bang = &to_wstring(tolua_S,2,0);
const std::wstring* arg = &to_wstring(tolua_S,3,0);
CMeterWindow* meterWindow = ((CMeterWindow*) tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ExecuteBang'", NULL);
#endif
{
BOOL tolua_ret = (BOOL) self->ExecuteBang(*bang,*arg,meterWindow);
{
#ifdef __cplusplus
void* tolua_obj = Mtolua_new((BOOL)(tolua_ret));
tolua_pushusertype(tolua_S,tolua_obj,"BOOL");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(BOOL));
tolua_pushusertype(tolua_S,tolua_obj,"BOOL");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
}
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'ExecuteBang'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: ParseCommand of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_ParseCommand00
static int tolua_rainmeter_CRainmeter_ParseCommand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CRainmeter",0,&tolua_err) ||
!is_wchar(tolua_S,2,"const WCHAR",0,&tolua_err) ||
!tolua_isusertype(tolua_S,3,"CMeterWindow",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,4,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CRainmeter* self = (CRainmeter*) tolua_tousertype(tolua_S,1,0);
const WCHAR* command = ((const WCHAR*) to_wchar(tolua_S,2,0));
CMeterWindow* meterWindow = ((CMeterWindow*) tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ParseCommand'", NULL);
#endif
{
std::wstring tolua_ret = (std::wstring) self->ParseCommand(command,meterWindow);
{
#ifdef __cplusplus
void* tolua_obj = Mtolua_new((std::wstring)(tolua_ret));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::wstring));
push_wstring(tolua_S,tolua_obj,"std::wstring");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
}
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'ParseCommand'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: ExecuteCommand of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_ExecuteCommand00
static int tolua_rainmeter_CRainmeter_ExecuteCommand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CRainmeter",0,&tolua_err) ||
!is_wchar(tolua_S,2,"const WCHAR",0,&tolua_err) ||
!tolua_isusertype(tolua_S,3,"CMeterWindow",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,4,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CRainmeter* self = (CRainmeter*) tolua_tousertype(tolua_S,1,0);
const WCHAR* command = ((const WCHAR*) to_wchar(tolua_S,2,0));
CMeterWindow* meterWindow = ((CMeterWindow*) tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ExecuteCommand'", NULL);
#endif
{
self->ExecuteCommand(command,meterWindow);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'ExecuteCommand'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: RefreshAll of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_RefreshAll00
static int tolua_rainmeter_CRainmeter_RefreshAll00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CRainmeter",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CRainmeter* self = (CRainmeter*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RefreshAll'", NULL);
#endif
{
self->RefreshAll();
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'RefreshAll'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: ClearDeleteLaterList of class CRainmeter */
#ifndef TOLUA_DISABLE_tolua_rainmeter_CRainmeter_ClearDeleteLaterList00
static int tolua_rainmeter_CRainmeter_ClearDeleteLaterList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"CRainmeter",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
CRainmeter* self = (CRainmeter*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ClearDeleteLaterList'", NULL);
#endif
{
self->ClearDeleteLaterList();
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'ClearDeleteLaterList'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* Open function */
TOLUA_API int tolua_rainmeter_open (lua_State* tolua_S)
{
@ -1276,27 +1053,28 @@ TOLUA_API int tolua_rainmeter_open (lua_State* tolua_S)
tolua_constant(tolua_S,"MAX_LINE_LENGTH",MAX_LINE_LENGTH);
tolua_cclass(tolua_S,"CRainmeter","CRainmeter","",NULL);
tolua_beginmodule(tolua_S,"CRainmeter");
tolua_function(tolua_S,"GetTrayWindow",tolua_rainmeter_CRainmeter_GetTrayWindow00);
tolua_function(tolua_S,"GetMeterWindow",tolua_rainmeter_CRainmeter_GetMeterWindow00);
tolua_function(tolua_S,"GetPath",tolua_rainmeter_CRainmeter_GetPath00);
tolua_function(tolua_S,"GetIniFile",tolua_rainmeter_CRainmeter_GetIniFile00);
tolua_function(tolua_S,"GetLogFile",tolua_rainmeter_CRainmeter_GetLogFile00);
tolua_function(tolua_S,"GetSkinPath",tolua_rainmeter_CRainmeter_GetSkinPath00);
tolua_function(tolua_S,"GetPluginPath",tolua_rainmeter_CRainmeter_GetPluginPath00);
tolua_function(tolua_S,"GetAddonPath",tolua_rainmeter_CRainmeter_GetAddonPath00);
tolua_function(tolua_S,"GetSettingsPath",tolua_rainmeter_CRainmeter_GetSettingsPath00);
tolua_function(tolua_S,"GetConfigEditor",tolua_rainmeter_CRainmeter_GetConfigEditor00);
tolua_function(tolua_S,"GetLogViewer",tolua_rainmeter_CRainmeter_GetLogViewer00);
tolua_function(tolua_S,"GetStatsDate",tolua_rainmeter_CRainmeter_GetStatsDate00);
tolua_function(tolua_S,"GetDebug",tolua_rainmeter_CRainmeter_GetDebug00);
tolua_function(tolua_S,"ReloadSettings",tolua_rainmeter_CRainmeter_ReloadSettings00);
tolua_function(tolua_S,"SaveSettings",tolua_rainmeter_CRainmeter_SaveSettings00);
tolua_function(tolua_S,"ReadStats",tolua_rainmeter_CRainmeter_ReadStats00);
tolua_function(tolua_S,"WriteStats",tolua_rainmeter_CRainmeter_WriteStats00);
tolua_function(tolua_S,"ResetStats",tolua_rainmeter_CRainmeter_ResetStats00);
tolua_function(tolua_S,"GetLogging",tolua_rainmeter_CRainmeter_GetLogging00);
tolua_function(tolua_S,"StartLogging",tolua_rainmeter_CRainmeter_StartLogging00);
tolua_function(tolua_S,"StopLogging",tolua_rainmeter_CRainmeter_StopLogging00);
tolua_function(tolua_S,"DeleteLogFile",tolua_rainmeter_CRainmeter_DeleteLogFile00);
tolua_function(tolua_S,"GetDisableRDP",tolua_rainmeter_CRainmeter_GetDisableRDP00);
tolua_function(tolua_S,"GetDisableDragging",tolua_rainmeter_CRainmeter_GetDisableDragging00);
tolua_function(tolua_S,"SetDisableDragging",tolua_rainmeter_CRainmeter_SetDisableDragging00);
tolua_function(tolua_S,"SetDebug",tolua_rainmeter_CRainmeter_SetDebug00);
tolua_function(tolua_S,"IsMenuActive",tolua_rainmeter_CRainmeter_IsMenuActive00);
tolua_function(tolua_S,"ShowContextMenu",tolua_rainmeter_CRainmeter_ShowContextMenu00);
@ -1306,11 +1084,6 @@ TOLUA_API int tolua_rainmeter_open (lua_State* tolua_S)
tolua_function(tolua_S,"GetTrayExecuteDR",tolua_rainmeter_CRainmeter_GetTrayExecuteDR00);
tolua_function(tolua_S,"GetTrayExecuteDL",tolua_rainmeter_CRainmeter_GetTrayExecuteDL00);
tolua_function(tolua_S,"GetTrayExecuteDM",tolua_rainmeter_CRainmeter_GetTrayExecuteDM00);
tolua_function(tolua_S,"ExecuteBang",tolua_rainmeter_CRainmeter_ExecuteBang00);
tolua_function(tolua_S,"ParseCommand",tolua_rainmeter_CRainmeter_ParseCommand00);
tolua_function(tolua_S,"ExecuteCommand",tolua_rainmeter_CRainmeter_ExecuteCommand00);
tolua_function(tolua_S,"RefreshAll",tolua_rainmeter_CRainmeter_RefreshAll00);
tolua_function(tolua_S,"ClearDeleteLaterList",tolua_rainmeter_CRainmeter_ClearDeleteLaterList00);
tolua_endmodule(tolua_S);
tolua_endmodule(tolua_S);
return 1;

2
Library/lua/glue/lua_rainmeter.h
View File

@ -1,6 +1,6 @@
/*
** Lua binding: rainmeter
** Generated automatically by tolua++-1.0.92 on 11/23/10 01:56:47.
** Generated automatically by tolua++-1.0.92 on 02/15/11 21:07:15.
*/
/* Exported function */

8
Library/lua/glue/lua_rainmeter_ext.cpp
View File

@ -1,5 +1,5 @@
/*
** Lua binding: group
** Lua binding: rainmeter_ext
** Generated automatically by tolua++-1.0.92 on 11/22/10 21:20:13.
*/
@ -11,10 +11,12 @@
#include "string.h"
#include "tolua++.h"
#include "../LuaManager.h"
/* Exported function */
TOLUA_API int luaopen_rainmeter_ext (lua_State* tolua_S);
#include "../LuaManager.h"
#include "../../MeterBar.h"
#include "../../MeterBitmap.h"
#include "../../MeterButton.h"
@ -99,7 +101,7 @@ static int staticLuaLog(lua_State* tolua_S)
/* list of functions in the module */
static const luaL_reg rainmeter_ext_funcs[] =
{
{ "LuaLog", staticLuaLog},
{ "LuaLog", staticLuaLog },
{ "MeterBar", AsMeterBar },
{ "MeterBitmap", AsMeterBitmap },
{ "MeterButton", AsMeterButton },

2
Library/lua/glue/lua_rainmeter_ext.h
View File

@ -1,5 +1,5 @@
/*
** Lua binding: group
** Lua binding: rainmeter_ext
** Generated automatically by tolua++-1.0.92 on 11/22/10 21:20:13.
*/

8
Library/lua/glue/meter_image.tolua
View File

@ -1,11 +1,11 @@
$#include "../MeterImage.h"
$#include "LuaPush.h"
$#include "../../MeterImage.h"
$#include "../LuaPush.h"
class CMeterImage : public CMeter
{
public:
void SetImage(const WCHAR* imageName);
const WCHAR* GetImage();
};