
// Auto generated

// include header:
//#include "qwidgetactionwrapper.h"
//#include "header_cpp.h"

#include "qwidgetaction_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QWidgetAction*> QWidgetAction_Wrapper::basecasters_QWidgetAction;

// static functions implementation in singleton wrapper:

// Class: QWidgetAction
// Function: tr
// Source: QObject
// Static: true
// Parameters: 3
// preceding Parameters: -1

QJSValue
QWidgetAction_WrapperSingleton::tr
(

    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3
)

{

    // check parameter types:
    if (
        RJSHelper::is_char_ptr(handler, a1
                               , true

                              )

        && RJSHelper::is_char_ptr(handler, a2
                                  , true

                                 )

        && RJSHelper::is_int(handler, a3
                             , true

                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: sourceText (char)


        // char pointer string:
        QByteArray a1_ba = RJSHelper::js2cpp_char_ptr(handler, a1).toLocal8Bit();
        const char* a1_cpp = a1_ba.constData();

        // convert js parameter to cpp:  (char)


        // char pointer string:
        QByteArray a2_ba = RJSHelper::js2cpp_char_ptr(handler, a2).toLocal8Bit();
        const char* a2_cpp = a2_ba.constData();

        // convert js parameter to cpp:  (int)

        int a3_cpp;


        if (a3.isUndefined()) {
            a3_cpp = -1;
        }
        else {
            a3_cpp = RJSHelper::js2cpp_int(handler, a3);
        }


        // call function:

        // static member function:
        // call base class static function:
        QString res =

            // call static member function:
            QObject::tr(
                a1_cpp
                , a2_cpp
                , a3_cpp

            );

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for tr";
    handler.trace();
    return QJSValue();

}

void QWidgetAction_Wrapper::init(RJSApi& handler) {

    //qmlRegisterType<QWidgetAction_Wrapper>("org.qcad", 1, 0, "QWidgetAction_Wrapper");
    qmlRegisterInterface<QWidgetAction_Wrapper>("QWidgetAction_Wrapper", 1);


    QJSEngine* engine = handler.getEngine();


    // make type scriptable for JS files:
    QJSValue global = engine->globalObject();
    RJSType_QWidgetAction* t = new RJSType_QWidgetAction();
    global.setProperty("RJSType_QWidgetAction", engine->newQObject(t));

    // initialize ID for this type:
    RJSType_QWidgetAction::getIdStatic();



    // wrapper:
    QJSValue mo = engine->newQMetaObject(&QWidgetAction_Wrapper::staticMetaObject);
    engine->globalObject().setProperty("QWidgetAction_Wrapper", mo);



    // JS base class:
    //QJSValue mob = engine->newQMetaObject(&QWidgetAction_BaseJs::staticMetaObject);
    //engine->globalObject().setProperty("QWidgetAction_BaseJs", mob);

    // singleton wrapper:
    QJSValue mos = engine->newQMetaObject(&QWidgetAction_WrapperSingleton::staticMetaObject);
    engine->globalObject().setProperty("QWidgetAction_WrapperSingleton", mos);

    // create instance of singleton wrapper for static functions:
    QWidgetAction_WrapperSingleton * s = new QWidgetAction_WrapperSingleton(handler);
    engine->globalObject().setProperty("QWidgetAction_WrapperSingletonInstance", engine->newQObject(s));
    QJSEngine::setObjectOwnership(s, QJSEngine::CppOwnership);

    QString fileName = ":generator/js/QWidgetAction.js";
    QFile scriptFile(fileName);
    if (!scriptFile.open(QIODevice::ReadOnly)) {
        qWarning() << "JS script wrapper file not found:" << fileName;
        return;
    }
    QTextStream stream(&scriptFile);
    QString contents = stream.readAll();
    scriptFile.close();

    qDebug() << "Evaluating file: " << fileName;
    QJSValue result = engine->evaluate(contents, fileName);
    if (result.isError()) {
        qWarning()
                << "Uncaught exception at line"
                << result.property("lineNumber").toInt()
                << ":" << result.toString();
    }
}

/*
// special constructor used as prototype:
QWidgetAction_Wrapper::QWidgetAction_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QWidgetAction_Wrapper");
        setEngine(e);

        // signal forwarding:
        //initConnections();
      }

*/


// special constructor to wrap existing object:
QWidgetAction_Wrapper::QWidgetAction_Wrapper(RJSApi& h, QWidgetAction* o, bool wrappedCreated) : RJSWrapperObj(h), wrapped(o), wrappedCreated(wrappedCreated) {
    //RDebug::incCounter(QString("QWidgetAction_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::incCounter(QString("QWidgetAction_Wrapper"));
    //setObjectName("QWidgetAction_Wrapper");
    //setHandler(h);

    // signal forwarding:
    initConnections();
}


// destructor:
QWidgetAction_Wrapper::~QWidgetAction_Wrapper() {
    //RDebug::decCounter(QString("QWidgetAction_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::decCounter(QString("QWidgetAction_Wrapper"));

    //qDebug() << "QWidgetAction_Wrapper::~QWidgetAction_Wrapper";

    // tell script handler that this wrapper no longer exists:
    handler.unregisterWrapper(*this);


    if (wrappedCreated) {

        // never delete wrapped object (non-copyable, CPP ownership or private destructor)
        //qDebug() << "NOT deleting instance of QWidgetAction";

    }

}

// initialization of signal forwarding

void QWidgetAction_Wrapper::initConnections() {

    //setObjectName("QWidgetAction_Wrapper");

    // tell script handler that this wrapper needs to be deleted if the engine is deleted:
    handler.registerWrapper(*this);


    // wrapped object is a QObject and not a wrapper for a null pointer:
    // wrapper is managed by the QObject as child:
    if (hasWrapped()) {
        QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);
    }


    if (hasWrapped()) {

        // set parent of wrapper to wrapped:
        // wrapper can be looked up for object:
        QVariant vThis = QVariant::fromValue(this);
        getWrapped()->setProperty("__wrapper__",  vThis);

        // make sure wrapper is deleted when object is deleted:
        // make sure wrapper stays alive as long as the wrapped stays alive::
        QObject::setParent(getWrapped());

        // set up signal forwarding:

        connect(
            getWrapped(),
            SIGNAL(changed()),
            this,
            SLOT(changedEmitter())
        );

        connect(
            getWrapped(),
            SIGNAL(triggered(bool)),
            this,
            SLOT(triggeredEmitter(bool))
        );

        connect(
            getWrapped(),
            SIGNAL(hovered()),
            this,
            SLOT(hoveredEmitter())
        );

        connect(
            getWrapped(),
            SIGNAL(toggled(bool)),
            this,
            SLOT(toggledEmitter(bool))
        );

        /*
        connect(
          getWrapped(),
          SIGNAL(destroyed(QObject*)),
          &handler,
          SLOT(slotDestroyed(QObject*))
        );
        */

    }
}


// constructors:

// Class: QWidgetAction
// Function:
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1
QWidgetAction_Wrapper::QWidgetAction_Wrapper

(

    // RJSApi:
    QObject* h
    ,
    const QJSValue&
    a1
)

    : RJSWrapperObj(*(RJSApi*)h)

{

    //RDebug::incCounter(QString("QWidgetAction_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::incCounter(QString("QWidgetAction_Wrapper"));

    // check parameter types:
    if (
        RJSHelper::is_QObject_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: parent (QObject)


        // pointer:
        QObject*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QObject_ptr(handler, a1);


        // call function:

        // construct wrapper:


        wrapped = new QWidgetAction(
            a1_cpp

        );
        wrappedCreated = true;


        // signal forwarding:
        // TODO
        //connect(wrapped, SIGNAL(triggered(bool)), this, SLOT(triggeredEmitter(bool)));
        initConnections();
        return;


    }

    // no constructor without arguments defined
    // allow constructor for prototype objects without args:
    if (
        a1.isUndefined()

    ) {
        wrapped = nullptr;
        wrappedCreated = false;
        return;
    }


    qWarning() << "no matching constructor variant found for QWidgetAction";
    wrapped = nullptr;
    wrappedCreated = false;
    handler.trace();

}


// non-static functions:

// Class: QWidgetAction
// Function: objectName
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::objectName
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QString res =

            w->objectName(

            );

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for objectName";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setObjectName
// Source: QObject
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setObjectName
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: name (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setObjectName(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setObjectName";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: isWidgetType
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::isWidgetType
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->isWidgetType(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isWidgetType";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: isWindowType
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::isWindowType
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->isWindowType(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isWindowType";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: signalsBlocked
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::signalsBlocked
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->signalsBlocked(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for signalsBlocked";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: blockSignals
// Source: QObject
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::blockSignals
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: b (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->blockSignals(
                a1_cpp

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for blockSignals";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: findChild
// Source: QObject
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::findChild
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                              , true

                             )

        && RJSHelper::is_Qt_FindChildOptions(handler, a2
                , true

                                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: aName (QString)

        QString a1_cpp;


        if (a1.isUndefined()) {
            a1_cpp = QString();
        }
        else {
            a1_cpp = RJSHelper::js2cpp_QString(handler, a1);
        }

        // convert js parameter to cpp: options (Qt::FindChildOptions)

        Qt::FindChildOptions a2_cpp;


        if (a2.isUndefined()) {
            a2_cpp = Qt::FindChildrenRecursively;
        }
        else {
            a2_cpp = RJSHelper::js2cpp_Qt_FindChildOptions(handler, a2);
        }


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QObject* res =

            w->findChild<QObject*>(
                a1_cpp
                , a2_cpp

            );

        // return type: QObject*

        return RJSHelper::cpp2js_QObject(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for findChild";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: children
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::children
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        // return type is reference:
        // use pointer instead 3:
        const QObjectList* res =
            &
            w->children(

            );

        // return type: const QObjectList&

        return RJSHelper::cpp2js_QObjectList(
                   handler,
                   // non-copyable: false
                   // return type is reference, type is copyable:
                   // convert pointer back to reference:
                   *res

               );

    }

    qWarning() << "no matching function variant found for children";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setParent
// Source: QObject
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setParent
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QObject_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: parent (QObject)


        // pointer:
        QObject*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QObject_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setParent(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setParent";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: installEventFilter
// Source: QObject
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::installEventFilter
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QObject_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: filterObj (QObject)


        // pointer:
        QObject*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QObject_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->installEventFilter(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for installEventFilter";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: removeEventFilter
// Source: QObject
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::removeEventFilter
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QObject_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: obj (QObject)


        // pointer:
        QObject*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QObject_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->removeEventFilter(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for removeEventFilter";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: dumpObjectTree
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::dumpObjectTree
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->dumpObjectTree(

        );

        return QJSValue();

    }

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->dumpObjectTree(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for dumpObjectTree";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: dumpObjectInfo
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::dumpObjectInfo
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->dumpObjectInfo(

        );

        return QJSValue();

    }

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->dumpObjectInfo(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for dumpObjectInfo";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setProperty
// Source: QObject
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setProperty
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_char_ptr(handler, a1
                               , true

                              )

        && RJSHelper::is_QVariant(handler, a2
                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: name (char)


        // char pointer string:
        QByteArray a1_ba = RJSHelper::js2cpp_char_ptr(handler, a1).toLocal8Bit();
        const char* a1_cpp = a1_ba.constData();

        // convert js parameter to cpp: value (QVariant)

        QVariant a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QVariant(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->setProperty(
                a1_cpp
                , a2_cpp

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for setProperty";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: property
// Source: QObject
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::property
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_char_ptr(handler, a1
                               , true

                              )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: name (char)


        // char pointer string:
        QByteArray a1_ba = RJSHelper::js2cpp_char_ptr(handler, a1).toLocal8Bit();
        const char* a1_cpp = a1_ba.constData();


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QVariant res =

            w->property(
                a1_cpp

            );

        // return type: QVariant

        return RJSHelper::cpp2js_QVariant(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for property";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: dynamicPropertyNames
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::dynamicPropertyNames
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QList<QByteArray> res =

            w->dynamicPropertyNames(

            );

        // return type: QList<QByteArray>

        return RJSHelper::cpp2js_QList_QByteArray(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for dynamicPropertyNames";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: parent
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::parent
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QObject* res =

            w->parent(

            );

        // return type: QObject*

        return RJSHelper::cpp2js_QObject(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for parent";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: deleteLater
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::deleteLater
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->deleteLater(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for deleteLater";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: associatedObjects
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::associatedObjects
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QList<QObject*> res =

            w->associatedObjects(

            );

        // return type: QList<QObject*>

        return RJSHelper::cpp2js_QList_QObject_ptr(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for associatedObjects";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setIcon
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setIcon
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QIcon(handler, a1
                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: icon (QIcon)

        QIcon a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QIcon(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setIcon(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setIcon";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: icon
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::icon
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QIcon res =

            w->icon(

            );

        // return type: QIcon

        return RJSHelper::cpp2js_QIcon(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for icon";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setText
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setText
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: text (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setText(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setText";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: text
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::text
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QString res =

            w->text(

            );

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for text";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setIconText
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setIconText
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: text (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setIconText(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setIconText";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: iconText
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::iconText
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QString res =

            w->iconText(

            );

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for iconText";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setToolTip
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setToolTip
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: tip (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setToolTip(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setToolTip";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: toolTip
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::toolTip
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QString res =

            w->toolTip(

            );

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for toolTip";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setStatusTip
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setStatusTip
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: statusTip (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setStatusTip(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setStatusTip";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: statusTip
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::statusTip
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QString res =

            w->statusTip(

            );

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for statusTip";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setWhatsThis
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setWhatsThis
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: what (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setWhatsThis(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setWhatsThis";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: whatsThis
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::whatsThis
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QString res =

            w->whatsThis(

            );

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for whatsThis";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setPriority
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setPriority
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAction_Priority(handler, a1
                                      )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: priority (QAction::Priority)

        QAction::Priority a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAction_Priority(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setPriority(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setPriority";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: priority
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::priority
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QAction::Priority res =

            w->priority(

            );

        // return type: QAction::Priority

        return RJSHelper::cpp2js_QAction_Priority(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for priority";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: menu
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::menu
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QMenu* res =

            w->menu(

            );

        // return type: QMenu*

        return RJSHelper::cpp2js_QMenu(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for menu";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setMenu
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setMenu
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QMenu_ptr(handler, a1
                                , true

                               )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: menu (QMenu)


        // pointer:
        QMenu*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QMenu_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setMenu(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setMenu";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setSeparator
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setSeparator
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: b (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setSeparator(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setSeparator";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: isSeparator
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::isSeparator
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->isSeparator(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isSeparator";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setShortcut
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setShortcut
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QKeySequence(handler, a1
                                  )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: shortcut (QKeySequence)

        QKeySequence a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QKeySequence(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setShortcut(
            a1_cpp

        );

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QKeySequence_StandardKey(handler, a1
                                              )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: shortcut (QKeySequence::StandardKey)

        QKeySequence::StandardKey a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QKeySequence_StandardKey(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setShortcut(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setShortcut";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: shortcut
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::shortcut
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QKeySequence res =

            w->shortcut(

            );

        // return type: QKeySequence

        return RJSHelper::cpp2js_QKeySequence(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for shortcut";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setShortcuts
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setShortcuts
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QList_QKeySequence(handler, a1
                                        )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: shortcuts (QList<QKeySequence>)

        QList<QKeySequence> a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QList_QKeySequence(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setShortcuts(
            a1_cpp

        );

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QKeySequence_StandardKey(handler, a1
                                              )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QKeySequence::StandardKey)

        QKeySequence::StandardKey a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QKeySequence_StandardKey(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setShortcuts(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setShortcuts";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: shortcuts
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::shortcuts
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QList<QKeySequence> res =

            w->shortcuts(

            );

        // return type: QList<QKeySequence>

        return RJSHelper::cpp2js_QList_QKeySequence(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for shortcuts";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setShortcutContext
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setShortcutContext
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_ShortcutContext(handler, a1
                                        )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: context (Qt::ShortcutContext)

        Qt::ShortcutContext a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_ShortcutContext(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setShortcutContext(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setShortcutContext";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: shortcutContext
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::shortcutContext
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        Qt::ShortcutContext res =

            w->shortcutContext(

            );

        // return type: Qt::ShortcutContext

        return RJSHelper::cpp2js_Qt_ShortcutContext(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for shortcutContext";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setAutoRepeat
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setAutoRepeat
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setAutoRepeat(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAutoRepeat";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: autoRepeat
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::autoRepeat
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->autoRepeat(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for autoRepeat";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setFont
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setFont
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QFont(handler, a1
                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: font (QFont)

        QFont a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QFont(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setFont(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setFont";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: font
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::font
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QFont res =

            w->font(

            );

        // return type: QFont

        return RJSHelper::cpp2js_QFont(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for font";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setCheckable
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setCheckable
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setCheckable(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setCheckable";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: isCheckable
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::isCheckable
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->isCheckable(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isCheckable";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: data
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::data
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QVariant res =

            w->data(

            );

        // return type: QVariant

        return RJSHelper::cpp2js_QVariant(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for data";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setData
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setData
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QVariant(handler, a1
                              )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: var (QVariant)

        QVariant a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QVariant(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setData(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setData";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: isChecked
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::isChecked
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->isChecked(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isChecked";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: isEnabled
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::isEnabled
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->isEnabled(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isEnabled";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: isVisible
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::isVisible
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->isVisible(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isVisible";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: showStatusText
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::showStatusText
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: widget (QWidget)


        // pointer:
        QWidget*
        a1_cpp;


        if (a1.isUndefined()) {
            a1_cpp = nullptr;
        }
        else {
            a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);
        }


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->showStatusText(
                a1_cpp

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for showStatusText";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setMenuRole
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setMenuRole
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAction_MenuRole(handler, a1
                                      )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: menuRole (QAction::MenuRole)

        QAction::MenuRole a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAction_MenuRole(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setMenuRole(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setMenuRole";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: menuRole
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::menuRole
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QAction::MenuRole res =

            w->menuRole(

            );

        // return type: QAction::MenuRole

        return RJSHelper::cpp2js_QAction_MenuRole(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for menuRole";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setIconVisibleInMenu
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setIconVisibleInMenu
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: visible (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setIconVisibleInMenu(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setIconVisibleInMenu";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: isIconVisibleInMenu
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::isIconVisibleInMenu
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->isIconVisibleInMenu(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isIconVisibleInMenu";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setShortcutVisibleInContextMenu
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setShortcutVisibleInContextMenu
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: show (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setShortcutVisibleInContextMenu(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setShortcutVisibleInContextMenu";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: isShortcutVisibleInContextMenu
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::isShortcutVisibleInContextMenu
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        bool res =

            w->isShortcutVisibleInContextMenu(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isShortcutVisibleInContextMenu";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: trigger
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::trigger
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->trigger(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for trigger";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: hover
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::hover
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->hover(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for hover";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setChecked
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setChecked
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setChecked(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setChecked";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: toggle
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::toggle
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->toggle(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for toggle";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setEnabled
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setEnabled
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setEnabled(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setEnabled";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setDisabled
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setDisabled
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: b (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setDisabled(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setDisabled";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: setVisible
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setVisible
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setVisible(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setVisible";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: changed
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QWidgetAction_Wrapper::changedEmitter(

) {
    // convert cpp parameters to js:


    emit changed(

    );
}

// Class: QWidgetAction
// Function: triggered
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QWidgetAction_Wrapper::triggeredEmitter(
    bool checked
) {
    // convert cpp parameters to js:

    // parameter: checked (bool)



    QJSValue a1_js = RJSHelper::cpp2js_bool(
                         handler,
                         checked
                     );


    emit triggered(
        a1_js
    );
}

// Class: QWidgetAction
// Function: hovered
// Source: QAction
// Static: false
// Parameters: 0
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QWidgetAction_Wrapper::hoveredEmitter(

) {
    // convert cpp parameters to js:


    emit hovered(

    );
}

// Class: QWidgetAction
// Function: toggled
// Source: QAction
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QWidgetAction_Wrapper::toggledEmitter(
    bool a1
) {
    // convert cpp parameters to js:

    // parameter:  (bool)



    QJSValue a1_js = RJSHelper::cpp2js_bool(
                         handler,
                         a1
                     );


    emit toggled(
        a1_js
    );
}

// Class: QWidgetAction
// Function: setDefaultWidget
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::setDefaultWidget
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: w (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->setDefaultWidget(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setDefaultWidget";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: defaultWidget
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::defaultWidget
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QWidget* res =

            w->defaultWidget(

            );

        // return type: QWidget*

        return RJSHelper::cpp2js_QWidget(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for defaultWidget";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: requestWidget
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::requestWidget
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: parent (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();
        QWidget* res =

            w->requestWidget(
                a1_cpp

            );

        // return type: QWidget*

        return RJSHelper::cpp2js_QWidget(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for requestWidget";
    handler.trace();
    return QJSValue();

}

// Class: QWidgetAction
// Function: releaseWidget
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWidgetAction_Wrapper::releaseWidget
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: widget (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QWidgetAction* w = getWrapped();

        w->releaseWidget(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for releaseWidget";
    handler.trace();
    return QJSValue();

}


// member functions for static properties, forward to static function



// protected overwritten functions / events and their public invokable counterparts:

