2018-08-22 21:33:38 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* luaEngine Lua Engine for Qt
|
2019-09-20 03:24:32 +02:00
|
|
|
* Copyright (C) 2018-2019 Syping
|
2018-08-22 21:33:38 +02:00
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
#define LUA_LIB
|
|
|
|
#include "LuaEngine.h"
|
|
|
|
#include <QTextStream>
|
2018-08-23 16:09:44 +02:00
|
|
|
#include <QMetaMethod>
|
2018-09-14 04:45:57 +02:00
|
|
|
#include <QtGlobal>
|
2018-08-22 21:33:38 +02:00
|
|
|
|
|
|
|
LuaEngine::LuaEngine(QObject *parent, bool loadBaseLibraries) : QObject(parent)
|
|
|
|
{
|
|
|
|
L = luaL_newstate();
|
|
|
|
if (loadBaseLibraries)
|
|
|
|
luaL_openlibs(L);
|
2018-08-23 16:09:44 +02:00
|
|
|
pushPointer("__LuaEngine", (void*)this);
|
2018-08-23 16:58:28 +02:00
|
|
|
pushVariant("DeleteInstant", 0);
|
|
|
|
pushVariant("DeleteLater", 1);
|
2018-09-15 01:56:50 +02:00
|
|
|
pushFunction("delete", luaObjectDelete_p);
|
|
|
|
pushFunction("getParent", luaObjectParent_p);
|
2018-08-23 16:09:44 +02:00
|
|
|
pushFunction("connect", luaTriggerConnect_p);
|
2018-08-23 16:58:28 +02:00
|
|
|
pushFunction("disconnect", luaTriggerDisconnect_p);
|
2018-08-22 21:33:38 +02:00
|
|
|
pushFunction("luaEngineVersion", luaEngineVersion_p);
|
2018-09-14 04:45:57 +02:00
|
|
|
pushFunction("luaEnginePlatform", luaEnginePlatform_p);
|
2018-08-22 21:33:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
LuaEngine::~LuaEngine()
|
|
|
|
{
|
|
|
|
lua_close(L);
|
|
|
|
}
|
|
|
|
|
|
|
|
lua_State* LuaEngine::luaState()
|
|
|
|
{
|
|
|
|
return L;
|
|
|
|
}
|
|
|
|
|
|
|
|
void LuaEngine::loadBaseLibraries()
|
|
|
|
{
|
|
|
|
luaL_openlibs(L);
|
|
|
|
}
|
|
|
|
|
2019-10-14 21:19:14 +02:00
|
|
|
int LuaEngine::luaEngineWriter_p(lua_State *L_p, const void *buffer, size_t size, void *array)
|
|
|
|
{
|
|
|
|
Q_UNUSED(L_p)
|
|
|
|
((QByteArray*)array)->append(QByteArray(static_cast<const char*>(buffer), (int)size));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-08-22 21:33:38 +02:00
|
|
|
int LuaEngine::luaEngineVersion_p(lua_State *L_p)
|
|
|
|
{
|
|
|
|
pushVariant(L_p, "0.1");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-09-14 04:45:57 +02:00
|
|
|
int LuaEngine::luaEnginePlatform_p(lua_State *L_p)
|
|
|
|
{
|
|
|
|
#ifdef Q_OS_ANDROID
|
|
|
|
pushVariant(L_p, "Android");
|
|
|
|
#elif defined(Q_OS_LINUX)
|
|
|
|
pushVariant(L_p, "Linux");
|
|
|
|
#elif defined(Q_OS_FREEBSD)
|
|
|
|
pushVariant(L_p, "FreeBSD");
|
|
|
|
#elif defined(Q_OS_OPENBSD)
|
|
|
|
pushVariant(L_p, "OpenBSD");
|
|
|
|
#elif defined(Q_OS_MACOS)
|
|
|
|
pushVariant(L_p, "macOS");
|
|
|
|
#elif defined(Q_OS_DARWIN)
|
|
|
|
pushVariant(L_p, "Darwin");
|
|
|
|
#elif defined(Q_OS_UNIX)
|
|
|
|
pushVariant(L_p, "Unix");
|
|
|
|
#elif defined(Q_OS_WIN)
|
|
|
|
pushVariant(L_p, "Windows");
|
|
|
|
#else
|
|
|
|
pushVariant(L_p, "Unknown");
|
|
|
|
#endif
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2019-10-14 21:19:14 +02:00
|
|
|
QByteArray LuaEngine::dumpLuaScript()
|
|
|
|
{
|
|
|
|
QByteArray array;
|
|
|
|
lua_lock(L);
|
|
|
|
lua_dump(L, luaEngineWriter_p, (void*)&array, 1);
|
|
|
|
lua_unlock(L);
|
|
|
|
return array;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool LuaEngine::loadLuaScript(const QByteArray &data)
|
2018-08-22 21:33:38 +02:00
|
|
|
{
|
2019-10-02 19:16:17 +02:00
|
|
|
int result = luaL_loadbuffer(L, data.data(), data.size(), "script");
|
2019-10-14 21:19:14 +02:00
|
|
|
return (result == 0) ? true : false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool LuaEngine::loadLuaScript(QIODevice *device, bool closeDevice)
|
|
|
|
{
|
|
|
|
QByteArray data;
|
|
|
|
if (!device->isOpen()) {
|
|
|
|
if (device->open(QIODevice::ReadOnly)) {
|
|
|
|
data = device->readAll();
|
|
|
|
if (closeDevice)
|
|
|
|
device->close();
|
|
|
|
return loadLuaScript(data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
data = device->readAll();
|
|
|
|
if (closeDevice)
|
|
|
|
device->close();
|
|
|
|
return loadLuaScript(data);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool LuaEngine::executeLuaScript(const QByteArray &data)
|
|
|
|
{
|
|
|
|
if (loadLuaScript(data))
|
2019-10-02 19:16:17 +02:00
|
|
|
return (lua_pcall(L, 0, LUA_MULTRET, 0) == 0) ? true : false;
|
|
|
|
return false;
|
2018-08-22 21:33:38 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool LuaEngine::executeLuaScript(QIODevice *device, bool closeDevice)
|
|
|
|
{
|
|
|
|
QByteArray data;
|
|
|
|
if (!device->isOpen()) {
|
|
|
|
if (device->open(QIODevice::ReadOnly)) {
|
|
|
|
data = device->readAll();
|
|
|
|
if (closeDevice)
|
|
|
|
device->close();
|
|
|
|
return executeLuaScript(data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
data = device->readAll();
|
|
|
|
if (closeDevice)
|
|
|
|
device->close();
|
|
|
|
return executeLuaScript(data);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool LuaEngine::executeLuaFunction(const char *name, bool requireReturn)
|
|
|
|
{
|
|
|
|
return executeLuaFunction(L, name, requireReturn);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool LuaEngine::executeLuaFunction(lua_State *L_p, const char *name, bool requireReturn)
|
|
|
|
{
|
2019-10-02 19:16:17 +02:00
|
|
|
int returnCount = (requireReturn) ? LUA_MULTRET : 0;
|
2018-08-22 21:33:38 +02:00
|
|
|
lua_getglobal(L_p, name);
|
|
|
|
return (lua_pcall(L_p, 0, returnCount, 0) == 0) ? true : false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool LuaEngine::executeLuaFunction(const char *name, const QVariant &argument, bool requireReturn)
|
|
|
|
{
|
|
|
|
return executeLuaFunction(L, name, argument, requireReturn);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool LuaEngine::executeLuaFunction(lua_State *L_p, const char *name, const QVariant &argument, bool requireReturn)
|
|
|
|
{
|
2019-10-02 19:16:17 +02:00
|
|
|
int returnCount = (requireReturn) ? LUA_MULTRET : 0;
|
2018-08-22 21:33:38 +02:00
|
|
|
lua_getglobal(L_p, name);
|
|
|
|
pushVariant(L_p, argument);
|
|
|
|
return (lua_pcall(L_p, 1, returnCount, 0) == 0) ? true : false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool LuaEngine::executeLuaFunction(const char *name, const QVariantList &args, bool requireReturn)
|
|
|
|
{
|
|
|
|
return executeLuaFunction(L, name, args, requireReturn);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool LuaEngine::executeLuaFunction(lua_State *L_p, const char *name, const QVariantList &args, bool requireReturn)
|
|
|
|
{
|
2019-10-02 19:16:17 +02:00
|
|
|
int returnCount = (requireReturn) ? LUA_MULTRET : 0;
|
2018-08-22 21:33:38 +02:00
|
|
|
lua_getglobal(L_p, name);
|
|
|
|
for (const QVariant &argument : args) {
|
|
|
|
pushVariant(L_p, argument);
|
|
|
|
}
|
|
|
|
return (lua_pcall(L_p, args.count(), returnCount, 0) == 0) ? true : false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void LuaEngine::pushFunction(const char *name, lua_CFunction function)
|
|
|
|
{
|
|
|
|
pushFunction(L, name, function);
|
|
|
|
}
|
|
|
|
|
|
|
|
void LuaEngine::pushFunction(lua_State *L_p, const char *name, lua_CFunction function)
|
|
|
|
{
|
|
|
|
lua_pushcfunction(L_p, function);
|
|
|
|
lua_setglobal(L_p, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
void LuaEngine::pushPointer(const char *name, void *pointer)
|
|
|
|
{
|
|
|
|
pushPointer(L, name, pointer);
|
|
|
|
}
|
|
|
|
|
|
|
|
void LuaEngine::pushPointer(lua_State *L_p, const char *name, void *pointer)
|
|
|
|
{
|
|
|
|
pushPointer(L_p, pointer);
|
|
|
|
lua_setglobal(L_p, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
void LuaEngine::pushPointer(void *pointer)
|
|
|
|
{
|
|
|
|
pushPointer(L, pointer);
|
|
|
|
}
|
|
|
|
|
|
|
|
void LuaEngine::pushPointer(lua_State *L_p, void *pointer)
|
|
|
|
{
|
|
|
|
lua_pushlightuserdata(L_p, pointer);
|
|
|
|
}
|
|
|
|
|
|
|
|
void LuaEngine::pushVariant(const char *name, const QVariant &variant)
|
|
|
|
{
|
|
|
|
pushVariant(L, name, variant);
|
|
|
|
}
|
|
|
|
|
|
|
|
void LuaEngine::pushVariant(lua_State *L_p, const char *name, const QVariant &variant)
|
|
|
|
{
|
|
|
|
pushVariant(L_p, variant);
|
|
|
|
lua_setglobal(L_p, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
void LuaEngine::pushVariant(const QVariant &variant)
|
|
|
|
{
|
|
|
|
pushVariant(L, variant);
|
|
|
|
}
|
|
|
|
|
|
|
|
void LuaEngine::pushVariant(lua_State *L_p, const QVariant &variant)
|
|
|
|
{
|
|
|
|
if (variant.type() == QVariant::Bool) {
|
|
|
|
lua_pushboolean(L_p, variant.toBool());
|
|
|
|
}
|
|
|
|
else if (variant.type() == QVariant::Int) {
|
|
|
|
lua_pushinteger(L_p, variant.toInt());
|
|
|
|
}
|
|
|
|
else if (variant.type() == QVariant::Double) {
|
|
|
|
lua_pushnumber(L_p, variant.toDouble());
|
|
|
|
}
|
|
|
|
else if (variant.type() == QVariant::String) {
|
|
|
|
lua_pushstring(L_p, variant.toString().toUtf8().data());
|
|
|
|
}
|
2019-10-01 05:28:37 +02:00
|
|
|
else if (variant.type() == QVariant::StringList) {
|
|
|
|
QStringList stringList = variant.toStringList();
|
|
|
|
lua_createtable(L_p, 0, stringList.count());
|
|
|
|
int currentId = 1;
|
|
|
|
for (const QString &string : stringList) {
|
|
|
|
lua_pushnumber(L_p, currentId);
|
|
|
|
lua_pushstring(L_p, string.toUtf8().data());
|
2019-10-02 19:16:17 +02:00
|
|
|
lua_settable(L_p, -3);
|
2019-10-01 05:28:37 +02:00
|
|
|
currentId++;
|
|
|
|
}
|
|
|
|
}
|
2019-10-21 21:28:37 +02:00
|
|
|
else if ((QMetaType::Type)variant.type() == QMetaType::QVariantList) {
|
|
|
|
QVariantList variantList = variant.toList();
|
|
|
|
lua_createtable(L_p, 0, variantList.count());
|
|
|
|
int currentId = 1;
|
|
|
|
for (const QVariant &variant : variantList) {
|
|
|
|
lua_pushnumber(L_p, currentId);
|
|
|
|
pushVariant(L_p, variant);
|
|
|
|
lua_settable(L_p, -3);
|
|
|
|
currentId++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ((QMetaType::Type)variant.type() == QMetaType::QVariantMap) {
|
|
|
|
QVariantMap variantMap = variant.toMap();
|
|
|
|
lua_createtable(L_p, 0, variantMap.count());
|
|
|
|
QVariantMap::const_iterator it = variantMap.constBegin();
|
|
|
|
QVariantMap::const_iterator end = variantMap.constEnd();
|
|
|
|
while (it != end) {
|
|
|
|
lua_pushstring(L_p, it.key().toUtf8().data());
|
|
|
|
pushVariant(L_p, it.value());
|
|
|
|
lua_settable(L_p, -3);
|
|
|
|
it++;
|
|
|
|
}
|
|
|
|
}
|
2018-08-22 21:33:38 +02:00
|
|
|
else if ((QMetaType::Type)variant.type() == QMetaType::Void || (QMetaType::Type)variant.type() == QMetaType::VoidStar) {
|
|
|
|
lua_pushlightuserdata(L_p, variant.value<void*>());
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
lua_pushnil(L_p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QVariant LuaEngine::getVariant(const char *name)
|
|
|
|
{
|
|
|
|
lua_getglobal(L, name);
|
|
|
|
return returnVariant();
|
|
|
|
}
|
|
|
|
|
|
|
|
QVariant LuaEngine::getVariant(lua_State *L_p, const char *name)
|
|
|
|
{
|
|
|
|
lua_getglobal(L_p, name);
|
|
|
|
return returnVariant(L_p);
|
|
|
|
}
|
|
|
|
|
|
|
|
QVariant LuaEngine::getVariant(int index)
|
|
|
|
{
|
|
|
|
return getVariant(L, index);
|
|
|
|
}
|
|
|
|
|
|
|
|
QVariant LuaEngine::getVariant(lua_State *L_p, int index)
|
|
|
|
{
|
|
|
|
if (lua_isboolean(L_p, index)) {
|
|
|
|
return QVariant::fromValue((bool)lua_toboolean(L_p, index));
|
|
|
|
}
|
|
|
|
else if (lua_isinteger(L_p, index)) {
|
|
|
|
return QVariant::fromValue(lua_tointeger(L_p, index));
|
|
|
|
}
|
|
|
|
else if (lua_isnumber(L_p, index)) {
|
|
|
|
return QVariant::fromValue(lua_tonumber(L_p, index));
|
|
|
|
}
|
|
|
|
else if (lua_isstring(L_p, index)) {
|
|
|
|
return QVariant::fromValue(QString(lua_tostring(L_p, index)));
|
|
|
|
}
|
2019-10-21 21:28:37 +02:00
|
|
|
else if (lua_istable(L_p, index)) {
|
|
|
|
QVariantMap variantMap;
|
|
|
|
lua_pushvalue(L_p, index);
|
|
|
|
lua_pushnil(L_p);
|
|
|
|
while (lua_next(L_p, -2) != 0) {
|
|
|
|
lua_pushvalue(L_p, -2);
|
|
|
|
QString key = QString(lua_tostring(L_p, -1));
|
|
|
|
QVariant value = getVariant(L_p, -2);
|
|
|
|
variantMap.insert(key, value);
|
|
|
|
lua_pop(L_p, 2);
|
|
|
|
}
|
|
|
|
lua_pop(L_p, 1);
|
|
|
|
return QVariant::fromValue(variantMap);
|
|
|
|
}
|
2018-08-22 21:33:38 +02:00
|
|
|
else if (lua_isuserdata(L_p, index)) {
|
|
|
|
return QVariant::fromValue(lua_touserdata(L_p, index));
|
|
|
|
}
|
2018-08-23 16:58:28 +02:00
|
|
|
else if (lua_isnoneornil(L_p, index)) {
|
2018-08-22 21:33:38 +02:00
|
|
|
return QVariant();
|
|
|
|
}
|
2018-08-23 16:58:28 +02:00
|
|
|
QTextStream(stderr) << "Warning: Didn't catch lua_isnoneornil before empty QVariant got returned" << endl;
|
2018-08-22 21:33:38 +02:00
|
|
|
return QVariant();
|
|
|
|
}
|
|
|
|
|
|
|
|
void* LuaEngine::returnPointer()
|
|
|
|
{
|
|
|
|
return returnPointer(L);
|
|
|
|
}
|
|
|
|
|
|
|
|
void* LuaEngine::returnPointer(lua_State *L_p)
|
|
|
|
{
|
|
|
|
return getPointer(L_p, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void* LuaEngine::getPointer(const char *name)
|
|
|
|
{
|
|
|
|
lua_getglobal(L, name);
|
|
|
|
return returnPointer();
|
|
|
|
}
|
|
|
|
|
|
|
|
void* LuaEngine::getPointer(lua_State *L_p, const char *name)
|
|
|
|
{
|
|
|
|
lua_getglobal(L_p, name);
|
|
|
|
return returnPointer(L_p);
|
|
|
|
}
|
|
|
|
|
|
|
|
void* LuaEngine::getPointer(int index)
|
|
|
|
{
|
|
|
|
return getPointer(L, index);
|
|
|
|
}
|
|
|
|
|
|
|
|
void* LuaEngine::getPointer(lua_State *L_p, int index)
|
|
|
|
{
|
|
|
|
return lua_touserdata(L_p, index);
|
|
|
|
}
|
|
|
|
|
|
|
|
QVariant LuaEngine::returnVariant()
|
|
|
|
{
|
|
|
|
return returnVariant(L);
|
|
|
|
}
|
|
|
|
|
|
|
|
QVariant LuaEngine::returnVariant(lua_State *L_p)
|
|
|
|
{
|
|
|
|
return getVariant(L_p, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
QVariantList LuaEngine::getArguments(lua_State *L_p)
|
|
|
|
{
|
|
|
|
QVariantList arguments;
|
|
|
|
int argumentCount = getArgumentCount(L_p);
|
|
|
|
for (int i = 1; i < (argumentCount + 1); i++) {
|
|
|
|
arguments << getVariant(L_p, i);
|
|
|
|
}
|
|
|
|
return arguments;
|
|
|
|
}
|
|
|
|
|
|
|
|
int LuaEngine::getArgumentCount(lua_State *L_p)
|
|
|
|
{
|
|
|
|
return lua_gettop(L_p);
|
|
|
|
}
|
2018-08-23 16:09:44 +02:00
|
|
|
|
2018-09-15 01:56:50 +02:00
|
|
|
int LuaEngine::luaObjectDelete_p(lua_State *L_p)
|
2018-08-23 16:58:28 +02:00
|
|
|
{
|
|
|
|
if (getArgumentCount(L_p) >= 1) {
|
|
|
|
void *pointer = getPointer(L_p, 1);
|
2018-08-23 17:02:12 +02:00
|
|
|
if (pointer != NULL) {
|
2018-08-23 16:58:28 +02:00
|
|
|
switch (getVariant(L_p, 2).toInt())
|
|
|
|
{
|
|
|
|
case 1:
|
|
|
|
((QObject*)pointer)->deleteLater();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
delete ((QObject*)pointer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-09-15 01:56:50 +02:00
|
|
|
int LuaEngine::luaObjectParent_p(lua_State *L_p)
|
|
|
|
{
|
|
|
|
if (getArgumentCount(L_p) >= 1) {
|
|
|
|
void *pointer = getPointer(L_p, 1);
|
|
|
|
if (pointer != NULL) {
|
|
|
|
pushPointer(L_p, ((QObject*)pointer)->parent());
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-08-23 16:09:44 +02:00
|
|
|
int LuaEngine::luaTriggerConnect_p(lua_State *L_p)
|
|
|
|
{
|
|
|
|
if (getArgumentCount(L_p) >= 3) {
|
2018-08-23 17:02:12 +02:00
|
|
|
void *pointer = getPointer(L_p, 1);
|
|
|
|
if (pointer != NULL) {
|
|
|
|
QObject *object = (QObject*)pointer;
|
|
|
|
QString signalString = getVariant(L_p, 2).toString();
|
|
|
|
int signalIndex = object->metaObject()->indexOfSignal(signalString.toUtf8().data());
|
|
|
|
if (signalIndex != -1) {
|
|
|
|
LuaEngine *engine = (LuaEngine*)getPointer(L_p, "__LuaEngine");
|
|
|
|
int slotIndex = engine->metaObject()->indexOfSlot("luaTriggerSlot_p()");
|
|
|
|
if (slotIndex != -1) {
|
|
|
|
QMetaMethod signal = object->metaObject()->method(signalIndex);
|
|
|
|
QMetaMethod slot = engine->metaObject()->method(slotIndex);
|
|
|
|
QString funcStorage;
|
|
|
|
QTextStream(&funcStorage) << "__ConnectFunc_" << object << "_" << signal.name();
|
|
|
|
pushVariant(L_p, funcStorage.toUtf8().data(), getVariant(L_p, 3).toString());
|
|
|
|
QObject::connect(object, signal, engine, slot);
|
|
|
|
}
|
2018-08-23 16:09:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-08-23 16:58:28 +02:00
|
|
|
int LuaEngine::luaTriggerDisconnect_p(lua_State *L_p)
|
|
|
|
{
|
|
|
|
if (getArgumentCount(L_p) >= 2) {
|
2018-08-23 17:02:12 +02:00
|
|
|
void *pointer = getPointer(L_p, 1);
|
|
|
|
if (pointer != NULL) {
|
|
|
|
QObject *object = (QObject*)pointer;
|
|
|
|
QString signalString = getVariant(L_p, 2).toString();
|
|
|
|
int signalIndex = object->metaObject()->indexOfSignal(signalString.toUtf8().data());
|
|
|
|
if (signalIndex != -1) {
|
|
|
|
LuaEngine *engine = (LuaEngine*)getPointer(L_p, "__LuaEngine");
|
|
|
|
int slotIndex = engine->metaObject()->indexOfSlot("luaTriggerSlot_p()");
|
|
|
|
if (slotIndex != -1) {
|
|
|
|
QMetaMethod signal = object->metaObject()->method(signalIndex);
|
|
|
|
QMetaMethod slot = engine->metaObject()->method(slotIndex);
|
|
|
|
QString funcStorage;
|
|
|
|
QTextStream(&funcStorage) << "__ConnectFunc_" << object << "_" << signal.name();
|
|
|
|
pushVariant(L_p, funcStorage.toUtf8().data(), QVariant());
|
|
|
|
QObject::disconnect(object, signal, engine, slot);
|
|
|
|
}
|
2018-08-23 16:58:28 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-08-23 16:09:44 +02:00
|
|
|
void LuaEngine::luaTriggerSlot_p()
|
|
|
|
{
|
|
|
|
QMetaMethod signal = sender()->metaObject()->method(senderSignalIndex());
|
|
|
|
QString funcStorage;
|
|
|
|
QTextStream(&funcStorage) << "__ConnectFunc_" << sender() << "_" << signal.name();
|
|
|
|
QString luaConnectFunc = getVariant(funcStorage.toUtf8().data()).toString();
|
|
|
|
executeLuaFunction(luaConnectFunc.toUtf8().data(), QVariant::fromValue((void*)sender()));
|
|
|
|
}
|