luaengineapp/src/luaenginegui/luaengine/LuaEngineGui.cpp

/*****************************************************************************
* luaEngine Lua Engine for Qt
* Copyright (C) 2018 Syping
*
* 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.
*****************************************************************************/

#include "LuaEngineGui.h"
#include <QMainWindow>
#include <QPushButton>
#include <QMessageBox>
#include <QMetaObject>
#include <QMetaMethod>
#include <QTextStream>
#include <QSpacerItem>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QSizePolicy>
#include <QEventLoop>
#include <QTextEdit>
#include <QLineEdit>
#include <QCheckBox>
#include <QMenuBar>
#include <QProcess>
#include <QWindow>
#include <QObject>
#include <QDialog>
#include <QTimer>
#include <QLabel>
#include <QDebug>

LuaEngineGui::LuaEngineGui(QObject *parent, bool loadBaseLibraries) : LuaEngine(parent, loadBaseLibraries)
{
    L = luaState();
    pushClass(L);
}

void LuaEngineGui::pushClass(lua_State *L_p)
{
    // MessageBox
    pushFunction(L_p, "showMessageBox", showMessageBox);
    pushVariant(L_p, "InfoMessageBox", 0);
    pushVariant(L_p, "WarningMessageBox", 1);
    pushVariant(L_p, "CriticalMessageBox", 2);
    pushVariant(L_p, "QuestionMessageBox", 3);

    // Gui
    pushVariant(L_p, "GuiExecuted", "GuiExecuted");

    // Widget
    pushFunction(L_p, "closeWidget", closeWidget);
    pushFunction(L_p, "executeWidget", executeWidget);
    pushFunction(L_p, "showWidget", showWidget);
    pushFunction(L_p, "getWidgetText", getWidgetText);
    pushFunction(L_p, "setWidgetFixedSize", setWidgetFixedSize);
    pushFunction(L_p, "setWidgetLayout", setWidgetLayout);
    pushFunction(L_p, "setWidgetText", setWidgetText);
    pushVariant(L_p, "ShowCurrent", 0);
    pushVariant(L_p, "ShowNormal", 1);
    pushVariant(L_p, "ShowMinimised", 2);
    pushVariant(L_p, "ShowMaximised", 3);
    pushVariant(L_p, "ShowFullscreen", 4);

    // Check Box
    pushFunction(L_p, "createCheckBox", createCheckBox);

    // Dialog
    pushFunction(L_p, "createDialog", createDialog);

    // Label
    pushFunction(L_p, "createLabel", createLabel);

    // Layout
    pushFunction(L_p, "createLayout", createLayout);
    pushFunction(L_p, "layoutAddLayout", layoutAddLayout);
    pushFunction(L_p, "layoutAddWidget", layoutAddWidget);
    pushFunction(L_p, "setLayoutMargins", setLayoutMargins);
    pushVariant(L_p, "HorizontalLayout", 0);
    pushVariant(L_p, "VerticalLayout", 1);

    // Line Edit
    pushFunction(L_p, "createLineEdit", createLineEdit);

    // Main Window
    pushFunction(L_p, "createMainWindow", createMainWindow);
    pushFunction(L_p, "createCentralWidget", createCentralWidget);

    // Menu
    pushFunction(L_p, "createMenu", createMenu);
    pushFunction(L_p, "createMenuBar", createMenuBar);
    pushFunction(L_p, "createMenuEntry", createMenuEntry);

    // Push Button
    pushFunction(L_p, "createPushButton", createPushButton);

    // Spacer Item
    pushFunction(L_p, "createSpacerItem", createSpacerItem);

    // Line Edit
    pushFunction(L_p, "createTextEdit", createTextEdit);

    // Size Policy
    pushVariant(L_p, "SizePolicyFixed", (int)QSizePolicy::Fixed);
    pushVariant(L_p, "SizePolicyMinimum", (int)QSizePolicy::Minimum);
    pushVariant(L_p, "SizePolicyMaximum", (int)QSizePolicy::Maximum);
    pushVariant(L_p, "SizePolicyPreferred", (int)QSizePolicy::Preferred);
    pushVariant(L_p, "SizePolicyExpanding", (int)QSizePolicy::Expanding);
    pushVariant(L_p, "SizePolicyIgnored", (int)QSizePolicy::Ignored);

    // Object functions
    pushFunction(L_p, "getParent", getParent);
}

void LuaEngineGui::pushClass(LuaEngine *luaEngine)
{
    pushClass(luaEngine->luaState());
}

int LuaEngineGui::showMessageBox(lua_State *L_p)
{
    QVariantList args = getArguments(L_p);
    if (args.length() >= 2) {
        QWidget *parent = nullptr;
        QString boxMessage = args.at(1).toString();
        QString boxTitle = "LuaEngine";
        if (args.length() >= 3) {
            boxTitle = args.at(2).toString();
            if (args.length() >= 4) {
                if ((QMetaType::Type)args.at(3).type() == QMetaType::Void || (QMetaType::Type)args.at(3).type() == QMetaType::VoidStar) {
                    if (((QObject*)qvariant_cast<void*>(args.at(3)))->inherits("QWidget")) {
                        parent = (QWidget*)qvariant_cast<void*>(args.at(3));
                    }
                }
            }
        }
        int returnInt = 0;
        switch (args.at(0).toInt()) {
        case 1:
            QMessageBox::warning(parent, boxTitle, boxMessage);
            break;
        case 2:
            QMessageBox::critical(parent, boxTitle, boxMessage);
            break;
        case 3:
        {
            bool returnCode = false;
            if (QMessageBox::Yes == QMessageBox::question(parent, boxTitle, boxMessage)) {
                returnCode = true;
            }
            pushVariant(L_p, returnCode);
            returnInt = 1;
        }
            break;
        default:
            QMessageBox::information(parent, boxTitle, boxMessage);
        }
        return returnInt;
    }
    else {
        return 0;
    }
}

int LuaEngineGui::closeWidget(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 1) {
        void *pointer = getPointer(L_p, 1);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QWidget")) {
            QWidget *widget = (QWidget*)pointer;
            widget->close();
            return 0;
        }
    }
    return 0;
}

int LuaEngineGui::executeWidget(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 1) {
        void *pointer = getPointer(L_p, 1);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QWidget")) {
            QVariant isFixed = ((QObject*)pointer)->property("isFixed");
            if (isFixed.type() == QVariant::Bool && isFixed.toBool()) {
                ((QWidget*)pointer)->setMinimumSize(((QWidget*)pointer)->sizeHint());
                ((QWidget*)pointer)->setMaximumSize(((QWidget*)pointer)->sizeHint());
            }
            else {
                ((QWidget*)pointer)->setMinimumSize(((QWidget*)pointer)->sizeHint());
                ((QWidget*)pointer)->setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
            }
            if (((QObject*)pointer)->inherits("QDialog")) {
                ((QDialog*)pointer)->exec();
            }
            else {
                ((QWidget*)pointer)->show();
                QEventLoop executeLoop;
                while (((QWidget*)pointer)->isVisible()) {
                    QTimer::singleShot(100, &executeLoop, SLOT(quit()));
                    executeLoop.exec();
                }
            }
            return 0;
        }
    }
    return 0;
}

int LuaEngineGui::showWidget(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 1) {
        void *pointer = getPointer(L_p, 1);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QWidget")) {
            int showMode = 0;
            if (getArgumentCount(L_p) >= 2) {
                showMode = getVariant(L_p, 2).toInt();
            }
            QVariant isFixed = ((QObject*)pointer)->property("isFixed");
            if (isFixed.type() == QVariant::Bool && isFixed.toBool()) {
                ((QWidget*)pointer)->setMinimumSize(((QWidget*)pointer)->sizeHint());
                ((QWidget*)pointer)->setMaximumSize(((QWidget*)pointer)->sizeHint());
            }
            else {
                ((QWidget*)pointer)->setMinimumSize(((QWidget*)pointer)->sizeHint());
                ((QWidget*)pointer)->setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
            }
            switch (showMode) {
            case 1:
                ((QWidget*)pointer)->showNormal();
                break;
            case 2:
                ((QWidget*)pointer)->showMinimized();
                break;
            case 3:
                ((QWidget*)pointer)->showMaximized();
                break;
            case 4:
                ((QWidget*)pointer)->showFullScreen();
                break;
            default:
                ((QWidget*)pointer)->show();
            }
            return 0;
        }
    }
    return 0;
}


int LuaEngineGui::setLayoutMargins(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 5) {
        void *pointer = getPointer(L_p, 1);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QLayout")) {
            ((QLayout*)pointer)->setContentsMargins(getVariant(L_p, 2).toInt(), getVariant(L_p, 3).toInt(), getVariant(L_p, 4).toInt(), getVariant(L_p, 5).toInt());
            return 0;
        }
    }
    return 0;
}
int LuaEngineGui::setWidgetFixedSize(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 1) {
        void *pointer = getPointer(L_p, 1);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QWidget")) {
            bool isFixed = true;
            if (getArgumentCount(L_p) >= 2) {
                isFixed = getVariant(L_p, 2).toBool();
            }
            ((QObject*)pointer)->setProperty("isFixed", isFixed);
            if (isFixed && ((QWidget*)pointer)->isVisible()) {
                ((QWidget*)pointer)->setMinimumSize(((QWidget*)pointer)->sizeHint());
                ((QWidget*)pointer)->setMaximumSize(((QWidget*)pointer)->sizeHint());
            }
            else if (((QWidget*)pointer)->isVisible()) {
                ((QWidget*)pointer)->setMinimumSize(((QWidget*)pointer)->sizeHint());
                ((QWidget*)pointer)->setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
            }
            return 0;
        }
    }
    return 0;
}

int LuaEngineGui::setWidgetLayout(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 2) {
        void *pointer = getPointer(L_p, 1);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QWidget")) {
            QWidget *widget = (QWidget*)pointer;
            void *l_pointer = getPointer(L_p, 2);
            if (l_pointer!= NULL && ((QObject*)l_pointer)->inherits("QLayout")) {
                widget->setLayout((QLayout*)l_pointer);
            }
        }
    }
    return 0;
}

int LuaEngineGui::setWidgetText(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 2) {
        void *pointer = getPointer(L_p, 1);
        if (pointer != NULL) {
            if (((QObject*)pointer)->inherits("QCheckBox")) {
                ((QCheckBox*)pointer)->setText(getVariant(L_p, 2).toString());
            }
            else if (((QObject*)pointer)->inherits("QLabel")) {
                ((QLabel*)pointer)->setText(getVariant(L_p, 2).toString());
            }
            else if (((QObject*)pointer)->inherits("QLineEdit")) {
                ((QLineEdit*)pointer)->setText(getVariant(L_p, 2).toString());
            }
            else if (((QObject*)pointer)->inherits("QTextEdit")) {
                ((QTextEdit*)pointer)->setText(getVariant(L_p, 2).toString());
            }
            else if (((QObject*)pointer)->inherits("QWidget")) {
                ((QWidget*)pointer)->setWindowTitle(getVariant(L_p, 2).toString());
            }
        }
    }
    return 0;
}

int LuaEngineGui::layoutAddLayout(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 2) {
        void *pointer = getPointer(L_p, 1);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QLayout")) {
            void *l_pointer = getPointer(L_p, 2);
            if (l_pointer!= NULL && ((QObject*)l_pointer)->inherits("QLayout")) {
                if (((QObject*)pointer)->inherits("QVBoxLayout")) {
                    QVBoxLayout *layout = (QVBoxLayout*)pointer;
                    layout->addLayout((QLayout*)l_pointer);
                }
                else if (((QObject*)pointer)->inherits("QHBoxLayout")) {
                    QHBoxLayout *layout = (QHBoxLayout*)pointer;
                    layout->addLayout((QLayout*)l_pointer);
                }
            }
        }
    }
    return 0;
}

int LuaEngineGui::layoutAddWidget(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 2) {
        void *pointer = getPointer(L_p, 1);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QLayout")) {
            QLayout *layout = (QLayout*)pointer;
            void *w_pointer = getPointer(L_p, 2);
            if (w_pointer!= NULL && ((QObject*)w_pointer)->inherits("QWidget")) {
                layout->addWidget((QWidget*)w_pointer);
            }
        }
    }
    return 0;
}

int LuaEngineGui::createCentralWidget(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 1) {
        void *pointer = getPointer(L_p, 1);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QMainWindow")) {
            QWidget *centralWidget = new QWidget((QWidget*)pointer);
            centralWidget->setObjectName(nameForPointer(centralWidget));
            ((QMainWindow*)pointer)->setCentralWidget(centralWidget);
            pushPointer(L_p, centralWidget);
            return 1;
        }
    }
    return 0;
}

int LuaEngineGui::createCheckBox(lua_State *L_p)
{
    QVariantList args = getArguments(L_p);
    QWidget *parent = nullptr;
    QString labelText = "LuaEngine";
    if (args.length() >= 1) {
        labelText = args.at(0).toString();
        if (args.length() >= 2) {
            if ((QMetaType::Type)args.at(1).type() == QMetaType::Void || (QMetaType::Type)args.at(1).type() == QMetaType::VoidStar) {
                if (((QObject*)qvariant_cast<void*>(args.at(1)))->inherits("QWidget")) {
                    parent = (QWidget*)qvariant_cast<void*>(args.at(1));
                }
            }
        }
    }
    QCheckBox *checkBox = new QCheckBox(parent);
    checkBox->setObjectName(nameForPointer(checkBox));
    checkBox->setText(labelText);
    pushPointer(L_p, checkBox);
    return 1;
}

int LuaEngineGui::createDialog(lua_State *L_p)
{
    QVariantList args = getArguments(L_p);
    QWidget *parent = nullptr;
    QString windowTitle = "LuaEngine";
    if (args.length() >= 1) {
        windowTitle = args.at(0).toString();
        if (args.length() >= 2) {
            if ((QMetaType::Type)args.at(1).type() == QMetaType::Void || (QMetaType::Type)args.at(1).type() == QMetaType::VoidStar) {
                if (((QObject*)qvariant_cast<void*>(args.at(1)))->inherits("QWidget")) {
                    parent = (QWidget*)qvariant_cast<void*>(args.at(1));
                }
            }
        }
    }
    QDialog *dialog = new QDialog(parent);
    dialog->setObjectName(nameForPointer(dialog));
    dialog->setWindowTitle(windowTitle);
    pushPointer(L_p, dialog);
    return 1;
}

int LuaEngineGui::createLabel(lua_State *L_p)
{
    QVariantList args = getArguments(L_p);
    QWidget *parent = nullptr;
    QString labelText = "LuaEngine";
    if (args.length() >= 1) {
        labelText = args.at(0).toString();
        if (args.length() >= 2) {
            if ((QMetaType::Type)args.at(1).type() == QMetaType::Void || (QMetaType::Type)args.at(1).type() == QMetaType::VoidStar) {
                if (((QObject*)qvariant_cast<void*>(args.at(1)))->inherits("QWidget")) {
                    parent = (QWidget*)qvariant_cast<void*>(args.at(1));
                }
            }
        }
    }
    QLabel *label = new QLabel(parent);
    label->setObjectName(nameForPointer(label));
    label->setText(labelText);
    pushPointer(L_p, label);
    return 1;
}

int LuaEngineGui::createLayout(lua_State *L_p)
{
    QWidget *parent = nullptr;
    QLayout *layoutParent = nullptr;
    if (getArgumentCount(L_p) >= 2) {
        void *pointer = getPointer(L_p, 2);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QWidget")) {
            parent = (QWidget*)pointer;
        }
        else if (pointer != NULL && ((QObject*)pointer)->inherits("QLayout")) {
            layoutParent = (QLayout*)pointer;
        }
    }
    void *layout;
    int layoutType = 0;
    if (getArgumentCount(L_p) >= 1) {
        layoutType = getVariant(L_p, 1).toInt();
    }
    switch (layoutType) {
    case 0:
        layout = new QHBoxLayout(parent);
        break;
    default:
        layout = new QVBoxLayout(parent);
    }
    ((QObject*)layout)->setObjectName(nameForPointer(layout));
    if (layoutParent != nullptr) {
        if (layoutParent->inherits("QVBoxLayout")) {
            ((QVBoxLayout*)layoutParent)->addLayout((QLayout*)layout);
        }
        else if (layoutParent->inherits("QHBoxLayout")) {
            ((QHBoxLayout*)layoutParent)->addLayout((QLayout*)layout);
        }
    }
    pushPointer(L_p, layout);
    return 1;
}

int LuaEngineGui::createLineEdit(lua_State *L_p)
{
    QVariantList args = getArguments(L_p);
    QWidget *parent = nullptr;
    QString editText = "LuaEngine";
    if (args.length() >= 1) {
        editText = args.at(0).toString();
        if (args.length() >= 2) {
            if ((QMetaType::Type)args.at(1).type() == QMetaType::Void || (QMetaType::Type)args.at(1).type() == QMetaType::VoidStar) {
                if (((QObject*)qvariant_cast<void*>(args.at(1)))->inherits("QWidget")) {
                    parent = (QWidget*)qvariant_cast<void*>(args.at(1));
                }
            }
        }
    }
    QLineEdit *lineEdit = new QLineEdit(parent);
    lineEdit->setObjectName(nameForPointer(lineEdit));
    lineEdit->setText(editText);
    pushPointer(L_p, lineEdit);
    return 1;
}

int LuaEngineGui::createMainWindow(lua_State *L_p)
{
    QVariantList args = getArguments(L_p);
    QWidget *parent = nullptr;
    QString windowTitle = "LuaEngine";
    if (args.length() >= 1) {
        windowTitle = args.at(0).toString();
        if (args.length() >= 2) {
            if ((QMetaType::Type)args.at(1).type() == QMetaType::Void || (QMetaType::Type)args.at(1).type() == QMetaType::VoidStar) {
                if (((QObject*)qvariant_cast<void*>(args.at(1)))->inherits("QWidget")) {
                    parent = (QWidget*)qvariant_cast<void*>(args.at(1));
                }
            }
        }
    }
    QMainWindow *mainWindow = new QMainWindow(parent);
    mainWindow->setObjectName(nameForPointer(mainWindow));
    mainWindow->setWindowTitle(windowTitle);
    pushPointer(L_p, mainWindow);
    return 1;
}

int LuaEngineGui::createMenu(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 2) {
        void *pointer = getPointer(L_p, 2);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QMenuBar")) {
            QMenu *menu = new QMenu((QWidget*)pointer);
            menu->setObjectName(nameForPointer(menu));
            menu->setTitle(getVariant(L_p, 1).toString());
            ((QMenuBar*)pointer)->addAction(menu->menuAction());
            pushPointer(L_p, menu);
            return 1;
        }
        else if (pointer != NULL && ((QObject*)pointer)->inherits("QMenu")) {
            QMenu *menu = new QMenu((QWidget*)pointer);
            menu->setObjectName(nameForPointer(menu));
            menu->setTitle(getVariant(L_p, 1).toString());
            ((QMenu*)pointer)->addAction(menu->menuAction());
            pushPointer(L_p, menu);
            return 1;
        }
    }
    return 0;
}

int LuaEngineGui::createMenuBar(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 1) {
        void *pointer = getPointer(L_p, 1);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QMainWindow")) {
            QMenuBar *menuBar = new QMenuBar((QWidget*)pointer);
            menuBar->setObjectName(nameForPointer(menuBar));
            ((QMainWindow*)pointer)->setMenuBar(menuBar);
            pushPointer(L_p, menuBar);
            return 1;
        }
    }
    return 0;
}

int LuaEngineGui::createMenuEntry(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 2) {
        void *pointer = getPointer(L_p, 2);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QMenu")) {
            QAction *action = new QAction(getVariant(L_p, 1).toString(), (QObject*)pointer);
            action->setObjectName(nameForPointer(action));
            ((QMenu*)pointer)->addAction(action);
            pushPointer(L_p, action);
            return 1;
        }
    }
    return 0;
}

int LuaEngineGui::createPushButton(lua_State *L_p)
{
    QVariantList args = getArguments(L_p);
    QWidget *parent = nullptr;
    QString buttonText = "LuaEngine";
    if (args.length() >= 1) {
        buttonText = args.at(0).toString();
        if (args.length() >= 2) {
            if ((QMetaType::Type)args.at(1).type() == QMetaType::Void || (QMetaType::Type)args.at(1).type() == QMetaType::VoidStar) {
                if (((QObject*)qvariant_cast<void*>(args.at(1)))->inherits("QWidget")) {
                    parent = (QWidget*)qvariant_cast<void*>(args.at(1));
                }
            }
        }
    }
    QPushButton *pushButton = new QPushButton(parent);
    pushButton->setObjectName(nameForPointer(pushButton));
    pushButton->setText(buttonText);
    pushPointer(L_p, pushButton);
    return 1;
}

int LuaEngineGui::createSpacerItem(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 3) {
        void *pointer = getPointer(L_p, 3);
        if (pointer != NULL && ((QObject*)pointer)->inherits("QLayout")) {
            if (((QObject*)pointer)->inherits("QVBoxLayout")) {
                QSpacerItem *spacerItem = new QSpacerItem(0, 0, (QSizePolicy::Policy)getVariant(L_p, 1).toInt(), (QSizePolicy::Policy)getVariant(L_p, 2).toInt());
                QVBoxLayout *layout = (QVBoxLayout*)pointer;
                layout->addSpacerItem(spacerItem);
                pushPointer(L_p, spacerItem);
                return 1;
            }
            else if (((QObject*)pointer)->inherits("QHBoxLayout")) {
                QSpacerItem *spacerItem = new QSpacerItem(0, 0, (QSizePolicy::Policy)getVariant(L_p, 1).toInt(), (QSizePolicy::Policy)getVariant(L_p, 2).toInt());
                QHBoxLayout *layout = (QHBoxLayout*)pointer;
                layout->addSpacerItem(spacerItem);
                pushPointer(L_p, spacerItem);
                return 1;
            }
        }
    }
    return 0;
}

int LuaEngineGui::createTextEdit(lua_State *L_p)
{
    QVariantList args = getArguments(L_p);
    QWidget *parent = nullptr;
    QString editText = "LuaEngine";
    if (args.length() >= 1) {
        editText = args.at(0).toString();
        if (args.length() >= 2) {
            if ((QMetaType::Type)args.at(1).type() == QMetaType::Void || (QMetaType::Type)args.at(1).type() == QMetaType::VoidStar) {
                if (((QObject*)qvariant_cast<void*>(args.at(1)))->inherits("QWidget")) {
                    parent = (QWidget*)qvariant_cast<void*>(args.at(1));
                }
            }
        }
    }
    QTextEdit *textEdit = new QTextEdit(parent);
    textEdit->setObjectName(nameForPointer(textEdit));
    textEdit->setText(editText);
    pushPointer(L_p, textEdit);
    return 1;
}

int LuaEngineGui::getParent(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;
}

int LuaEngineGui::getWidgetText(lua_State *L_p)
{
    if (getArgumentCount(L_p) >= 1) {
        void *pointer = getPointer(L_p, 1);
        if (pointer != NULL) {
            if (((QObject*)pointer)->inherits("QCheckBox")) {
                pushVariant(L_p, ((QCheckBox*)pointer)->text());
                return 1;
            }
            else if (((QObject*)pointer)->inherits("QLabel")) {
                pushVariant(L_p, ((QLabel*)pointer)->text());
                return 1;
            }
            else if (((QObject*)pointer)->inherits("QLineEdit")) {
                pushVariant(L_p, ((QLineEdit*)pointer)->text());
                return 1;
            }
            else if (((QObject*)pointer)->inherits("QTextEdit")) {
                pushVariant(L_p, ((QTextEdit*)pointer)->toPlainText());
                return 1;
            }
            else if (((QObject*)pointer)->inherits("QWidget")) {
                pushVariant(L_p, ((QWidget*)pointer)->windowTitle());
                return 1;
            }
        }
    }
    return 0;
}

QString LuaEngineGui::nameForPointer(void *pointer)
{
    QString nameStorage;
    QTextStream(&nameStorage) << "LuaEngineGui" << pointer;
    return nameStorage;
}