
// Auto generated

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

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QInputEvent*> QInputEvent_Wrapper::basecasters_QInputEvent;

// static functions implementation in singleton wrapper:

// Class: QInputEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QInputEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

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

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


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


        // call function:

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

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

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

               );

    }

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

}

void QInputEvent_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

    QString fileName = ":generator/js/QInputEvent.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:
QInputEvent_Wrapper::QInputEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QInputEvent_Wrapper");
        setEngine(e);

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

*/


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

    // signal forwarding:
    initConnections();
}


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

    //qDebug() << "QInputEvent_Wrapper::~QInputEvent_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 QInputEvent";

    }

}

// initialization of signal forwarding

void QInputEvent_Wrapper::initConnections() {

    //setObjectName("QInputEvent_Wrapper");

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


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:


// non-static functions:

// Class: QInputEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::type
(

)

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:
        QInputEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

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

               );

    }

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

}

// Class: QInputEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::spontaneous
(

)

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:
        QInputEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QInputEvent
// Function: setAccepted
// Source: QEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QInputEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QInputEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::isAccepted
(

)

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:
        QInputEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QInputEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QInputEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

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

}

// Class: QInputEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QInputEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

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

}

// Class: QInputEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::isInputEvent
(

)

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:
        QInputEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QInputEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::isPointerEvent
(

)

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:
        QInputEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QInputEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::isSinglePointEvent
(

)

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:
        QInputEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QInputEvent
// Function: clone
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::clone
(

)

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:
        QInputEvent* w = getWrapped();
        QInputEvent* res =

            w->clone(

            );

        // return type: QInputEvent*

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

               );

    }

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

}

// Class: QInputEvent
// Function: modifiers
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::modifiers
(

)

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:
        QInputEvent* w = getWrapped();
        Qt::KeyboardModifiers res =

            w->modifiers(

            );

        // return type: Qt::KeyboardModifiers

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

               );

    }

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

}

// Class: QInputEvent
// Function: setModifiers
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::setModifiers
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(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:
        QInputEvent* w = getWrapped();

        w->setModifiers(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QInputEvent
// Function: timestamp
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::timestamp
(

)

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:
        QInputEvent* w = getWrapped();
        quint64 res =

            w->timestamp(

            );

        // return type: quint64

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

               );

    }

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

}

// Class: QInputEvent
// Function: setTimestamp
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QInputEvent_Wrapper::setTimestamp
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: timestamp (quint64)

        quint64 a1_cpp;

        a1_cpp = RJSHelper::js2cpp_quint64(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:
        QInputEvent* w = getWrapped();

        w->setTimestamp(
            a1_cpp

        );

        return QJSValue();

    }

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

}


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



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

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QPointerEvent*> QPointerEvent_Wrapper::basecasters_QPointerEvent;

// static functions implementation in singleton wrapper:

// Class: QPointerEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QPointerEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

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

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


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


        // call function:

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

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

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

               );

    }

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

}

void QPointerEvent_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

    QString fileName = ":generator/js/QPointerEvent.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:
QPointerEvent_Wrapper::QPointerEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QPointerEvent_Wrapper");
        setEngine(e);

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

*/


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

    // signal forwarding:
    initConnections();
}


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

    //qDebug() << "QPointerEvent_Wrapper::~QPointerEvent_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 QPointerEvent";

    }

}

// initialization of signal forwarding

void QPointerEvent_Wrapper::initConnections() {

    //setObjectName("QPointerEvent_Wrapper");

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


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:


// non-static functions:

// Class: QPointerEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::type
(

)

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:
        QPointerEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

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

               );

    }

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

}

// Class: QPointerEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::spontaneous
(

)

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:
        QPointerEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPointerEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::isAccepted
(

)

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:
        QPointerEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPointerEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QPointerEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

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

}

// Class: QPointerEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QPointerEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

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

}

// Class: QPointerEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::isInputEvent
(

)

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:
        QPointerEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPointerEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::isPointerEvent
(

)

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:
        QPointerEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPointerEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::isSinglePointEvent
(

)

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:
        QPointerEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPointerEvent
// Function: modifiers
// Source: QInputEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::modifiers
(

)

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:
        QPointerEvent* w = getWrapped();
        Qt::KeyboardModifiers res =

            w->modifiers(

            );

        // return type: Qt::KeyboardModifiers

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

               );

    }

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

}

// Class: QPointerEvent
// Function: setModifiers
// Source: QInputEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::setModifiers
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(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:
        QPointerEvent* w = getWrapped();

        w->setModifiers(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QPointerEvent
// Function: timestamp
// Source: QInputEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::timestamp
(

)

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:
        QPointerEvent* w = getWrapped();
        quint64 res =

            w->timestamp(

            );

        // return type: quint64

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

               );

    }

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

}

// Class: QPointerEvent
// Function: clone
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::clone
(

)

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:
        QPointerEvent* w = getWrapped();
        QPointerEvent* res =

            w->clone(

            );

        // return type: QPointerEvent*

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

               );

    }

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

}

// Class: QPointerEvent
// Function: setTimestamp
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::setTimestamp
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: timestamp (quint64)

        quint64 a1_cpp;

        a1_cpp = RJSHelper::js2cpp_quint64(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:
        QPointerEvent* w = getWrapped();

        w->setTimestamp(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QPointerEvent
// Function: pointCount
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::pointCount
(

)

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:
        QPointerEvent* w = getWrapped();
        qsizetype res =

            w->pointCount(

            );

        // return type: qsizetype

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

               );

    }

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

}

// Class: QPointerEvent
// Function: point
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::point
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: i (qsizetype)

        qsizetype a1_cpp;

        a1_cpp = RJSHelper::js2cpp_qsizetype(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:
        QPointerEvent* w = getWrapped();

        // return type is reference:
        // use pointer instead 3:
        QEventPoint* res =
            &
            w->point(
                a1_cpp

            );

        // return type: QEventPoint&

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

               );

    }

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

}

// Class: QPointerEvent
// Function: pointById
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::pointById
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: id (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(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:
        QPointerEvent* w = getWrapped();
        QEventPoint* res =

            w->pointById(
                a1_cpp

            );

        // return type: QEventPoint*

        return RJSHelper::cpp2js_QEventPoint(
                   handler,
                   // non-copyable: false
                   // return type is pointer, type is copyable:
                   // call pointer implementation of RJSHelper::cpp2js_QEventPoint:
                   res

               );

    }

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

}

// Class: QPointerEvent
// Function: allPointsGrabbed
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::allPointsGrabbed
(

)

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:
        QPointerEvent* w = getWrapped();
        bool res =

            w->allPointsGrabbed(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPointerEvent
// Function: isBeginEvent
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::isBeginEvent
(

)

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:
        QPointerEvent* w = getWrapped();
        bool res =

            w->isBeginEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPointerEvent
// Function: isUpdateEvent
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::isUpdateEvent
(

)

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:
        QPointerEvent* w = getWrapped();
        bool res =

            w->isUpdateEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPointerEvent
// Function: isEndEvent
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::isEndEvent
(

)

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:
        QPointerEvent* w = getWrapped();
        bool res =

            w->isEndEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPointerEvent
// Function: allPointsAccepted
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::allPointsAccepted
(

)

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:
        QPointerEvent* w = getWrapped();
        bool res =

            w->allPointsAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPointerEvent
// Function: setAccepted
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QPointerEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QPointerEvent
// Function: exclusiveGrabber
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::exclusiveGrabber
(

    const QJSValue&
    a1
)

const

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QEventPoint(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:
        QPointerEvent* w = getWrapped();
        QObject* res =

            w->exclusiveGrabber(
                a1_cpp

            );

        // return type: QObject*

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

               );

    }

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

}

// Class: QPointerEvent
// Function: setExclusiveGrabber
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::setExclusiveGrabber
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

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

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


        // pointer:
        QObject*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QObject_ptr(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:
        QPointerEvent* w = getWrapped();

        w->setExclusiveGrabber(
            a1_cpp
            , a2_cpp

        );

        return QJSValue();

    }

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

}

// Class: QPointerEvent
// Function: clearPassiveGrabbers
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::clearPassiveGrabbers
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QEventPoint(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:
        QPointerEvent* w = getWrapped();

        w->clearPassiveGrabbers(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QPointerEvent
// Function: addPassiveGrabber
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::addPassiveGrabber
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

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

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


        // pointer:
        QObject*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QObject_ptr(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:
        QPointerEvent* w = getWrapped();
        bool res =

            w->addPassiveGrabber(
                a1_cpp
                , a2_cpp

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPointerEvent
// Function: removePassiveGrabber
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QPointerEvent_Wrapper::removePassiveGrabber
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

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

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


        // pointer:
        QObject*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QObject_ptr(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:
        QPointerEvent* w = getWrapped();
        bool res =

            w->removePassiveGrabber(
                a1_cpp
                , a2_cpp

            );

        // return type: bool

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

               );

    }

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

}


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



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

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QSinglePointEvent*> QSinglePointEvent_Wrapper::basecasters_QSinglePointEvent;

// static functions implementation in singleton wrapper:

// Class: QSinglePointEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QSinglePointEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

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

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


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


        // call function:

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

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

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

               );

    }

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

}

void QSinglePointEvent_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

    QString fileName = ":generator/js/QSinglePointEvent.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:
QSinglePointEvent_Wrapper::QSinglePointEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QSinglePointEvent_Wrapper");
        setEngine(e);

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

*/


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

    // signal forwarding:
    initConnections();
}


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

    //qDebug() << "QSinglePointEvent_Wrapper::~QSinglePointEvent_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 QSinglePointEvent";

    }

}

// initialization of signal forwarding

void QSinglePointEvent_Wrapper::initConnections() {

    //setObjectName("QSinglePointEvent_Wrapper");

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


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:


// non-static functions:

// Class: QSinglePointEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::type
(

)

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:
        QSinglePointEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::spontaneous
(

)

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:
        QSinglePointEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::isAccepted
(

)

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:
        QSinglePointEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QSinglePointEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

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

}

// Class: QSinglePointEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QSinglePointEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

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

}

// Class: QSinglePointEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::isInputEvent
(

)

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:
        QSinglePointEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::isPointerEvent
(

)

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:
        QSinglePointEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::isSinglePointEvent
(

)

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:
        QSinglePointEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: setTimestamp
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::setTimestamp
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: timestamp (quint64)

        quint64 a1_cpp;

        a1_cpp = RJSHelper::js2cpp_quint64(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:
        QSinglePointEvent* w = getWrapped();

        w->setTimestamp(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QSinglePointEvent
// Function: pointCount
// Source: QPointerEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::pointCount
(

)

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:
        QSinglePointEvent* w = getWrapped();
        qsizetype res =

            w->pointCount(

            );

        // return type: qsizetype

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: point
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::point
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: i (qsizetype)

        qsizetype a1_cpp;

        a1_cpp = RJSHelper::js2cpp_qsizetype(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:
        QSinglePointEvent* w = getWrapped();

        // return type is reference:
        // use pointer instead 3:
        QEventPoint* res =
            &
            w->point(
                a1_cpp

            );

        // return type: QEventPoint&

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: pointById
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::pointById
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: id (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(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:
        QSinglePointEvent* w = getWrapped();
        QEventPoint* res =

            w->pointById(
                a1_cpp

            );

        // return type: QEventPoint*

        return RJSHelper::cpp2js_QEventPoint(
                   handler,
                   // non-copyable: false
                   // return type is pointer, type is copyable:
                   // call pointer implementation of RJSHelper::cpp2js_QEventPoint:
                   res

               );

    }

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

}

// Class: QSinglePointEvent
// Function: allPointsGrabbed
// Source: QPointerEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::allPointsGrabbed
(

)

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:
        QSinglePointEvent* w = getWrapped();
        bool res =

            w->allPointsGrabbed(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: allPointsAccepted
// Source: QPointerEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::allPointsAccepted
(

)

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:
        QSinglePointEvent* w = getWrapped();
        bool res =

            w->allPointsAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: setAccepted
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QSinglePointEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QSinglePointEvent
// Function: exclusiveGrabber
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::exclusiveGrabber
(

    const QJSValue&
    a1
)

const

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QEventPoint(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:
        QSinglePointEvent* w = getWrapped();
        QObject* res =

            w->exclusiveGrabber(
                a1_cpp

            );

        // return type: QObject*

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: setExclusiveGrabber
// Source: QPointerEvent
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::setExclusiveGrabber
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

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

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


        // pointer:
        QObject*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QObject_ptr(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:
        QSinglePointEvent* w = getWrapped();

        w->setExclusiveGrabber(
            a1_cpp
            , a2_cpp

        );

        return QJSValue();

    }

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

}

// Class: QSinglePointEvent
// Function: clearPassiveGrabbers
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::clearPassiveGrabbers
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QEventPoint(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:
        QSinglePointEvent* w = getWrapped();

        w->clearPassiveGrabbers(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QSinglePointEvent
// Function: addPassiveGrabber
// Source: QPointerEvent
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::addPassiveGrabber
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

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

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


        // pointer:
        QObject*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QObject_ptr(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:
        QSinglePointEvent* w = getWrapped();
        bool res =

            w->addPassiveGrabber(
                a1_cpp
                , a2_cpp

            );

        // return type: bool

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: removePassiveGrabber
// Source: QPointerEvent
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::removePassiveGrabber
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

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

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


        // pointer:
        QObject*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QObject_ptr(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:
        QSinglePointEvent* w = getWrapped();
        bool res =

            w->removePassiveGrabber(
                a1_cpp
                , a2_cpp

            );

        // return type: bool

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: button
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::button
(

)

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:
        QSinglePointEvent* w = getWrapped();
        Qt::MouseButton res =

            w->button(

            );

        // return type: Qt::MouseButton

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: buttons
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::buttons
(

)

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:
        QSinglePointEvent* w = getWrapped();
        Qt::MouseButtons res =

            w->buttons(

            );

        // return type: Qt::MouseButtons

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: position
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::position
(

)

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:
        QSinglePointEvent* w = getWrapped();
        QPointF res =

            w->position(

            );

        // return type: QPointF

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: scenePosition
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::scenePosition
(

)

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:
        QSinglePointEvent* w = getWrapped();
        QPointF res =

            w->scenePosition(

            );

        // return type: QPointF

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: globalPosition
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::globalPosition
(

)

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:
        QSinglePointEvent* w = getWrapped();
        QPointF res =

            w->globalPosition(

            );

        // return type: QPointF

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: isBeginEvent
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::isBeginEvent
(

)

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:
        QSinglePointEvent* w = getWrapped();
        bool res =

            w->isBeginEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: isUpdateEvent
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::isUpdateEvent
(

)

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:
        QSinglePointEvent* w = getWrapped();
        bool res =

            w->isUpdateEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: isEndEvent
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::isEndEvent
(

)

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:
        QSinglePointEvent* w = getWrapped();
        bool res =

            w->isEndEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: exclusivePointGrabber
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::exclusivePointGrabber
(

)

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:
        QSinglePointEvent* w = getWrapped();
        QObject* res =

            w->exclusivePointGrabber(

            );

        // return type: QObject*

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

               );

    }

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

}

// Class: QSinglePointEvent
// Function: setExclusivePointGrabber
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::setExclusivePointGrabber
(

    const QJSValue&
    a1
)

{

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

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: exclusiveGrabber (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:
        QSinglePointEvent* w = getWrapped();

        w->setExclusivePointGrabber(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QSinglePointEvent
// Function: clone
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QSinglePointEvent_Wrapper::clone
(

)

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:
        QSinglePointEvent* w = getWrapped();
        QSinglePointEvent* res =

            w->clone(

            );

        // return type: QSinglePointEvent*

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

               );

    }

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

}


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



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

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QMouseEvent*> QMouseEvent_Wrapper::basecasters_QMouseEvent;

// static functions implementation in singleton wrapper:

// Class: QMouseEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QMouseEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

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

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


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


        // call function:

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

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

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

               );

    }

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

}

#ifndef QT_NO_INTEGER_EVENT_COORDINATES

#endif

void QMouseEvent_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

    QString fileName = ":generator/js/QMouseEvent.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:
QMouseEvent_Wrapper::QMouseEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QMouseEvent_Wrapper");
        setEngine(e);

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

*/


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

    // signal forwarding:
    initConnections();
}


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

    //qDebug() << "QMouseEvent_Wrapper::~QMouseEvent_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 QMouseEvent";

    }

}

// initialization of signal forwarding

void QMouseEvent_Wrapper::initConnections() {

    //setObjectName("QMouseEvent_Wrapper");

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


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

// Class: QMouseEvent
// Function:
// Source:
// Static: false
// Parameters: 8
// preceding Parameters: -1
QMouseEvent_Wrapper::QMouseEvent_Wrapper

(

    // RJSApi:
    QObject* h
    ,
    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3,
    const QJSValue&
    a4,
    const QJSValue&
    a5,
    const QJSValue&
    a6,
    const QJSValue&
    a7,
    const QJSValue&
    a8
)

    : RJSWrapperObj(*(RJSApi*)h)

{

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

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

        && RJSHelper::is_QPointF(handler, a2
                                )

        && RJSHelper::is_QPointF(handler, a3
                                )

        && RJSHelper::is_QPointF(handler, a4
                                )

        && RJSHelper::is_Qt_MouseButton(handler, a5
                                       )

        && RJSHelper::is_Qt_MouseButtons(handler, a6
                                        )

        && RJSHelper::is_Qt_KeyboardModifiers(handler, a7
                                             )

        && RJSHelper::is_Qt_MouseEventSource(handler, a8
                                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: type (QEvent::Type)

        QEvent::Type a1_cpp;

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

        // convert js parameter to cpp: localPos (QPointF)

        QPointF a2_cpp;

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

        // convert js parameter to cpp: windowPos (QPointF)

        QPointF a3_cpp;

        a3_cpp = RJSHelper::js2cpp_QPointF(handler, a3);

        // convert js parameter to cpp: screenPos (QPointF)

        QPointF a4_cpp;

        a4_cpp = RJSHelper::js2cpp_QPointF(handler, a4);

        // convert js parameter to cpp: button (Qt::MouseButton)

        Qt::MouseButton a5_cpp;

        a5_cpp = RJSHelper::js2cpp_Qt_MouseButton(handler, a5);

        // convert js parameter to cpp: buttons (Qt::MouseButtons)

        Qt::MouseButtons a6_cpp;

        a6_cpp = RJSHelper::js2cpp_Qt_MouseButtons(handler, a6);

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a7_cpp;

        a7_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(handler, a7);

        // convert js parameter to cpp: source (Qt::MouseEventSource)

        Qt::MouseEventSource a8_cpp;

        a8_cpp = RJSHelper::js2cpp_Qt_MouseEventSource(handler, a8);


        // call function:

        // construct wrapper:


        wrapped = new QMouseEvent(
            a1_cpp
            , a2_cpp
            , a3_cpp
            , a4_cpp
            , a5_cpp
            , a6_cpp
            , a7_cpp
            , a8_cpp

        );
        wrappedCreated = true;


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


    }

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

        && RJSHelper::is_QPointF(handler, a2
                                )

        && RJSHelper::is_QPointF(handler, a3
                                )

        && RJSHelper::is_QPointF(handler, a4
                                )

        && RJSHelper::is_Qt_MouseButton(handler, a5
                                       )

        && RJSHelper::is_Qt_MouseButtons(handler, a6
                                        )

        && RJSHelper::is_Qt_KeyboardModifiers(handler, a7
                                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: type (QEvent::Type)

        QEvent::Type a1_cpp;

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

        // convert js parameter to cpp: localPos (QPointF)

        QPointF a2_cpp;

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

        // convert js parameter to cpp: windowPos (QPointF)

        QPointF a3_cpp;

        a3_cpp = RJSHelper::js2cpp_QPointF(handler, a3);

        // convert js parameter to cpp: screenPos (QPointF)

        QPointF a4_cpp;

        a4_cpp = RJSHelper::js2cpp_QPointF(handler, a4);

        // convert js parameter to cpp: button (Qt::MouseButton)

        Qt::MouseButton a5_cpp;

        a5_cpp = RJSHelper::js2cpp_Qt_MouseButton(handler, a5);

        // convert js parameter to cpp: buttons (Qt::MouseButtons)

        Qt::MouseButtons a6_cpp;

        a6_cpp = RJSHelper::js2cpp_Qt_MouseButtons(handler, a6);

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a7_cpp;

        a7_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(handler, a7);


        // call function:

        // construct wrapper:


        wrapped = new QMouseEvent(
            a1_cpp
            , a2_cpp
            , a3_cpp
            , a4_cpp
            , a5_cpp
            , a6_cpp
            , a7_cpp

        );
        wrappedCreated = true;


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


    }

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

        && RJSHelper::is_QPointF(handler, a2
                                )

        && RJSHelper::is_QPointF(handler, a3
                                )

        && RJSHelper::is_Qt_MouseButton(handler, a4
                                       )

        && RJSHelper::is_Qt_MouseButtons(handler, a5
                                        )

        && RJSHelper::is_Qt_KeyboardModifiers(handler, a6
                                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: type (QEvent::Type)

        QEvent::Type a1_cpp;

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

        // convert js parameter to cpp: localPos (QPointF)

        QPointF a2_cpp;

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

        // convert js parameter to cpp: screenPos (QPointF)

        QPointF a3_cpp;

        a3_cpp = RJSHelper::js2cpp_QPointF(handler, a3);

        // convert js parameter to cpp: button (Qt::MouseButton)

        Qt::MouseButton a4_cpp;

        a4_cpp = RJSHelper::js2cpp_Qt_MouseButton(handler, a4);

        // convert js parameter to cpp: buttons (Qt::MouseButtons)

        Qt::MouseButtons a5_cpp;

        a5_cpp = RJSHelper::js2cpp_Qt_MouseButtons(handler, a5);

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a6_cpp;

        a6_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(handler, a6);


        // call function:

        // construct wrapper:


        wrapped = new QMouseEvent(
            a1_cpp
            , a2_cpp
            , a3_cpp
            , a4_cpp
            , a5_cpp
            , a6_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()
        && a2.isUndefined()
        && a3.isUndefined()
        && a4.isUndefined()
        && a5.isUndefined()
        && a6.isUndefined()
        && a7.isUndefined()
        && a8.isUndefined()

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


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

}

#ifndef QT_NO_INTEGER_EVENT_COORDINATES

#endif


// non-static functions:

// Class: QMouseEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::type
(

)

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:
        QMouseEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

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

               );

    }

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

}

// Class: QMouseEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::spontaneous
(

)

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:
        QMouseEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QMouseEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::isAccepted
(

)

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:
        QMouseEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QMouseEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QMouseEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

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

}

// Class: QMouseEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QMouseEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

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

}

// Class: QMouseEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::isInputEvent
(

)

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:
        QMouseEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QMouseEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::isPointerEvent
(

)

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:
        QMouseEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QMouseEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::isSinglePointEvent
(

)

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:
        QMouseEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QMouseEvent
// Function: modifiers
// Source: QInputEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::modifiers
(

)

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:
        QMouseEvent* w = getWrapped();
        Qt::KeyboardModifiers res =

            w->modifiers(

            );

        // return type: Qt::KeyboardModifiers

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

               );

    }

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

}

// Class: QMouseEvent
// Function: setModifiers
// Source: QInputEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::setModifiers
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(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:
        QMouseEvent* w = getWrapped();

        w->setModifiers(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QMouseEvent
// Function: timestamp
// Source: QInputEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::timestamp
(

)

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:
        QMouseEvent* w = getWrapped();
        quint64 res =

            w->timestamp(

            );

        // return type: quint64

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

               );

    }

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

}

// Class: QMouseEvent
// Function: setTimestamp
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::setTimestamp
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: timestamp (quint64)

        quint64 a1_cpp;

        a1_cpp = RJSHelper::js2cpp_quint64(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:
        QMouseEvent* w = getWrapped();

        w->setTimestamp(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QMouseEvent
// Function: pointCount
// Source: QPointerEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::pointCount
(

)

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:
        QMouseEvent* w = getWrapped();
        qsizetype res =

            w->pointCount(

            );

        // return type: qsizetype

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

               );

    }

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

}

// Class: QMouseEvent
// Function: point
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::point
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: i (qsizetype)

        qsizetype a1_cpp;

        a1_cpp = RJSHelper::js2cpp_qsizetype(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:
        QMouseEvent* w = getWrapped();

        // return type is reference:
        // use pointer instead 3:
        QEventPoint* res =
            &
            w->point(
                a1_cpp

            );

        // return type: QEventPoint&

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

               );

    }

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

}

// Class: QMouseEvent
// Function: pointById
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::pointById
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: id (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(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:
        QMouseEvent* w = getWrapped();
        QEventPoint* res =

            w->pointById(
                a1_cpp

            );

        // return type: QEventPoint*

        return RJSHelper::cpp2js_QEventPoint(
                   handler,
                   // non-copyable: false
                   // return type is pointer, type is copyable:
                   // call pointer implementation of RJSHelper::cpp2js_QEventPoint:
                   res

               );

    }

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

}

// Class: QMouseEvent
// Function: allPointsGrabbed
// Source: QPointerEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::allPointsGrabbed
(

)

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:
        QMouseEvent* w = getWrapped();
        bool res =

            w->allPointsGrabbed(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QMouseEvent
// Function: allPointsAccepted
// Source: QPointerEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::allPointsAccepted
(

)

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:
        QMouseEvent* w = getWrapped();
        bool res =

            w->allPointsAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QMouseEvent
// Function: setAccepted
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QMouseEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QMouseEvent
// Function: exclusiveGrabber
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::exclusiveGrabber
(

    const QJSValue&
    a1
)

const

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QEventPoint(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:
        QMouseEvent* w = getWrapped();
        QObject* res =

            w->exclusiveGrabber(
                a1_cpp

            );

        // return type: QObject*

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

               );

    }

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

}

// Class: QMouseEvent
// Function: setExclusiveGrabber
// Source: QPointerEvent
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::setExclusiveGrabber
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

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

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


        // pointer:
        QObject*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QObject_ptr(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:
        QMouseEvent* w = getWrapped();

        w->setExclusiveGrabber(
            a1_cpp
            , a2_cpp

        );

        return QJSValue();

    }

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

}

// Class: QMouseEvent
// Function: clearPassiveGrabbers
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::clearPassiveGrabbers
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QEventPoint(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:
        QMouseEvent* w = getWrapped();

        w->clearPassiveGrabbers(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QMouseEvent
// Function: addPassiveGrabber
// Source: QPointerEvent
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::addPassiveGrabber
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

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

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


        // pointer:
        QObject*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QObject_ptr(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:
        QMouseEvent* w = getWrapped();
        bool res =

            w->addPassiveGrabber(
                a1_cpp
                , a2_cpp

            );

        // return type: bool

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

               );

    }

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

}

// Class: QMouseEvent
// Function: removePassiveGrabber
// Source: QPointerEvent
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::removePassiveGrabber
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

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

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


        // pointer:
        QObject*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QObject_ptr(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:
        QMouseEvent* w = getWrapped();
        bool res =

            w->removePassiveGrabber(
                a1_cpp
                , a2_cpp

            );

        // return type: bool

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

               );

    }

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

}

// Class: QMouseEvent
// Function: position
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::position
(

)

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:
        QMouseEvent* w = getWrapped();
        QPointF res =

            w->position(

            );

        // return type: QPointF

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

               );

    }

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

}

// Class: QMouseEvent
// Function: scenePosition
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::scenePosition
(

)

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:
        QMouseEvent* w = getWrapped();
        QPointF res =

            w->scenePosition(

            );

        // return type: QPointF

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

               );

    }

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

}

// Class: QMouseEvent
// Function: globalPosition
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::globalPosition
(

)

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:
        QMouseEvent* w = getWrapped();
        QPointF res =

            w->globalPosition(

            );

        // return type: QPointF

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

               );

    }

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

}

// Class: QMouseEvent
// Function: isBeginEvent
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::isBeginEvent
(

)

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:
        QMouseEvent* w = getWrapped();
        bool res =

            w->isBeginEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QMouseEvent
// Function: isUpdateEvent
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::isUpdateEvent
(

)

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:
        QMouseEvent* w = getWrapped();
        bool res =

            w->isUpdateEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QMouseEvent
// Function: isEndEvent
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::isEndEvent
(

)

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:
        QMouseEvent* w = getWrapped();
        bool res =

            w->isEndEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QMouseEvent
// Function: exclusivePointGrabber
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::exclusivePointGrabber
(

)

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:
        QMouseEvent* w = getWrapped();
        QObject* res =

            w->exclusivePointGrabber(

            );

        // return type: QObject*

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

               );

    }

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

}

// Class: QMouseEvent
// Function: setExclusivePointGrabber
// Source: QSinglePointEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::setExclusivePointGrabber
(

    const QJSValue&
    a1
)

{

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

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: exclusiveGrabber (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:
        QMouseEvent* w = getWrapped();

        w->setExclusivePointGrabber(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QMouseEvent
// Function: clone
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::clone
(

)

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:
        QMouseEvent* w = getWrapped();
        QSinglePointEvent* res =

            w->clone(

            );

        // return type: QSinglePointEvent*

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

               );

    }

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

}

#ifndef QT_NO_INTEGER_EVENT_COORDINATES

// Class: QMouseEvent
// Function: pos
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::pos
(

)

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:
        QMouseEvent* w = getWrapped();
        QPoint res =

            w->pos(

            );

        // return type: QPoint

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

               );

    }

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

}

#endif

// Class: QMouseEvent
// Function: button
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::button
(

)

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:
        QMouseEvent* w = getWrapped();
        Qt::MouseButton res =

            w->button(

            );

        // return type: Qt::MouseButton

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

               );

    }

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

}

// Class: QMouseEvent
// Function: buttons
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::buttons
(

)

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:
        QMouseEvent* w = getWrapped();
        Qt::MouseButtons res =

            w->buttons(

            );

        // return type: Qt::MouseButtons

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

               );

    }

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

}

// Class: QMouseEvent
// Function: source
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::source
(

)

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:
        QMouseEvent* w = getWrapped();
        Qt::MouseEventSource res =

            w->source(

            );

        // return type: Qt::MouseEventSource

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

               );

    }

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

}

// Class: QMouseEvent
// Function: flags
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QMouseEvent_Wrapper::flags
(

)

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:
        QMouseEvent* w = getWrapped();
        Qt::MouseEventFlags res =

            w->flags(

            );

        // return type: Qt::MouseEventFlags

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

               );

    }

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

}


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



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

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QWheelEvent*> QWheelEvent_Wrapper::basecasters_QWheelEvent;

// static functions implementation in singleton wrapper:

// Class: QWheelEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWheelEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

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

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


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


        // call function:

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

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

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

               );

    }

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

}

void QWheelEvent_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

    QString fileName = ":generator/js/QWheelEvent.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:
QWheelEvent_Wrapper::QWheelEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QWheelEvent_Wrapper");
        setEngine(e);

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

*/


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

    // signal forwarding:
    initConnections();
}


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

    //qDebug() << "QWheelEvent_Wrapper::~QWheelEvent_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 QWheelEvent";

    }

}

// initialization of signal forwarding

void QWheelEvent_Wrapper::initConnections() {

    //setObjectName("QWheelEvent_Wrapper");

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


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

// Class: QWheelEvent
// Function:
// Source:
// Static: false
// Parameters: 9
// preceding Parameters: -1
QWheelEvent_Wrapper::QWheelEvent_Wrapper

(

    // RJSApi:
    QObject* h
    ,
    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3,
    const QJSValue&
    a4,
    const QJSValue&
    a5,
    const QJSValue&
    a6,
    const QJSValue&
    a7,
    const QJSValue&
    a8,
    const QJSValue&
    a9
)

    : RJSWrapperObj(*(RJSApi*)h)

{

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

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

        && RJSHelper::is_QPointF(handler, a2
                                )

        && RJSHelper::is_QPoint(handler, a3
                               )

        && RJSHelper::is_QPoint(handler, a4
                               )

        && RJSHelper::is_Qt_MouseButtons(handler, a5
                                        )

        && RJSHelper::is_Qt_KeyboardModifiers(handler, a6
                                             )

        && RJSHelper::is_Qt_ScrollPhase(handler, a7
                                       )

        && RJSHelper::is_bool(handler, a8
                             )

        && RJSHelper::is_Qt_MouseEventSource(handler, a9
                , true

                                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: pos (QPointF)

        QPointF a1_cpp;

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

        // convert js parameter to cpp: globalPos (QPointF)

        QPointF a2_cpp;

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

        // convert js parameter to cpp: pixelDelta (QPoint)

        QPoint a3_cpp;

        a3_cpp = RJSHelper::js2cpp_QPoint(handler, a3);

        // convert js parameter to cpp: angleDelta (QPoint)

        QPoint a4_cpp;

        a4_cpp = RJSHelper::js2cpp_QPoint(handler, a4);

        // convert js parameter to cpp: buttons (Qt::MouseButtons)

        Qt::MouseButtons a5_cpp;

        a5_cpp = RJSHelper::js2cpp_Qt_MouseButtons(handler, a5);

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a6_cpp;

        a6_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(handler, a6);

        // convert js parameter to cpp: phase (Qt::ScrollPhase)

        Qt::ScrollPhase a7_cpp;

        a7_cpp = RJSHelper::js2cpp_Qt_ScrollPhase(handler, a7);

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

        bool a8_cpp;

        a8_cpp = RJSHelper::js2cpp_bool(handler, a8);

        // convert js parameter to cpp: source (Qt::MouseEventSource)

        Qt::MouseEventSource a9_cpp;


        if (a9.isUndefined()) {
            a9_cpp = Qt::MouseEventNotSynthesized;
        }
        else {
            a9_cpp = RJSHelper::js2cpp_Qt_MouseEventSource(handler, a9);
        }


        // call function:

        // construct wrapper:


        wrapped = new QWheelEvent(
            a1_cpp
            , a2_cpp
            , a3_cpp
            , a4_cpp
            , a5_cpp
            , a6_cpp
            , a7_cpp
            , a8_cpp
            , a9_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()
        && a2.isUndefined()
        && a3.isUndefined()
        && a4.isUndefined()
        && a5.isUndefined()
        && a6.isUndefined()
        && a7.isUndefined()
        && a8.isUndefined()
        && a9.isUndefined()

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


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

}


// non-static functions:

// Class: QWheelEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::type
(

)

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:
        QWheelEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

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

               );

    }

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

}

// Class: QWheelEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::spontaneous
(

)

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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::isAccepted
(

)

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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QWheelEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

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

}

// Class: QWheelEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QWheelEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

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

}

// Class: QWheelEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::isInputEvent
(

)

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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::isPointerEvent
(

)

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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::isSinglePointEvent
(

)

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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: modifiers
// Source: QInputEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::modifiers
(

)

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:
        QWheelEvent* w = getWrapped();
        Qt::KeyboardModifiers res =

            w->modifiers(

            );

        // return type: Qt::KeyboardModifiers

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

               );

    }

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

}

// Class: QWheelEvent
// Function: setModifiers
// Source: QInputEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::setModifiers
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(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:
        QWheelEvent* w = getWrapped();

        w->setModifiers(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QWheelEvent
// Function: timestamp
// Source: QInputEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::timestamp
(

)

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:
        QWheelEvent* w = getWrapped();
        quint64 res =

            w->timestamp(

            );

        // return type: quint64

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

               );

    }

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

}

// Class: QWheelEvent
// Function: setTimestamp
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::setTimestamp
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: timestamp (quint64)

        quint64 a1_cpp;

        a1_cpp = RJSHelper::js2cpp_quint64(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:
        QWheelEvent* w = getWrapped();

        w->setTimestamp(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QWheelEvent
// Function: pointCount
// Source: QPointerEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::pointCount
(

)

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:
        QWheelEvent* w = getWrapped();
        qsizetype res =

            w->pointCount(

            );

        // return type: qsizetype

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

               );

    }

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

}

// Class: QWheelEvent
// Function: point
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::point
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: i (qsizetype)

        qsizetype a1_cpp;

        a1_cpp = RJSHelper::js2cpp_qsizetype(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:
        QWheelEvent* w = getWrapped();

        // return type is reference:
        // use pointer instead 3:
        QEventPoint* res =
            &
            w->point(
                a1_cpp

            );

        // return type: QEventPoint&

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

               );

    }

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

}

// Class: QWheelEvent
// Function: pointById
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::pointById
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: id (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(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:
        QWheelEvent* w = getWrapped();
        QEventPoint* res =

            w->pointById(
                a1_cpp

            );

        // return type: QEventPoint*

        return RJSHelper::cpp2js_QEventPoint(
                   handler,
                   // non-copyable: false
                   // return type is pointer, type is copyable:
                   // call pointer implementation of RJSHelper::cpp2js_QEventPoint:
                   res

               );

    }

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

}

// Class: QWheelEvent
// Function: allPointsGrabbed
// Source: QPointerEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::allPointsGrabbed
(

)

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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->allPointsGrabbed(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: allPointsAccepted
// Source: QPointerEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::allPointsAccepted
(

)

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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->allPointsAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: setAccepted
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QWheelEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QWheelEvent
// Function: exclusiveGrabber
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::exclusiveGrabber
(

    const QJSValue&
    a1
)

const

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QEventPoint(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:
        QWheelEvent* w = getWrapped();
        QObject* res =

            w->exclusiveGrabber(
                a1_cpp

            );

        // return type: QObject*

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

               );

    }

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

}

// Class: QWheelEvent
// Function: setExclusiveGrabber
// Source: QPointerEvent
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::setExclusiveGrabber
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

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

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


        // pointer:
        QObject*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QObject_ptr(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:
        QWheelEvent* w = getWrapped();

        w->setExclusiveGrabber(
            a1_cpp
            , a2_cpp

        );

        return QJSValue();

    }

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

}

// Class: QWheelEvent
// Function: clearPassiveGrabbers
// Source: QPointerEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::clearPassiveGrabbers
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QEventPoint(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:
        QWheelEvent* w = getWrapped();

        w->clearPassiveGrabbers(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QWheelEvent
// Function: addPassiveGrabber
// Source: QPointerEvent
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::addPassiveGrabber
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

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

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


        // pointer:
        QObject*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QObject_ptr(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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->addPassiveGrabber(
                a1_cpp
                , a2_cpp

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: removePassiveGrabber
// Source: QPointerEvent
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::removePassiveGrabber
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QEventPoint)

        QEventPoint a1_cpp;

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

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


        // pointer:
        QObject*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QObject_ptr(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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->removePassiveGrabber(
                a1_cpp
                , a2_cpp

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: button
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::button
(

)

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:
        QWheelEvent* w = getWrapped();
        Qt::MouseButton res =

            w->button(

            );

        // return type: Qt::MouseButton

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

               );

    }

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

}

// Class: QWheelEvent
// Function: buttons
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::buttons
(

)

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:
        QWheelEvent* w = getWrapped();
        Qt::MouseButtons res =

            w->buttons(

            );

        // return type: Qt::MouseButtons

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

               );

    }

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

}

// Class: QWheelEvent
// Function: position
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::position
(

)

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:
        QWheelEvent* w = getWrapped();
        QPointF res =

            w->position(

            );

        // return type: QPointF

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

               );

    }

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

}

// Class: QWheelEvent
// Function: scenePosition
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::scenePosition
(

)

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:
        QWheelEvent* w = getWrapped();
        QPointF res =

            w->scenePosition(

            );

        // return type: QPointF

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

               );

    }

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

}

// Class: QWheelEvent
// Function: globalPosition
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::globalPosition
(

)

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:
        QWheelEvent* w = getWrapped();
        QPointF res =

            w->globalPosition(

            );

        // return type: QPointF

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

               );

    }

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

}

// Class: QWheelEvent
// Function: exclusivePointGrabber
// Source: QSinglePointEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::exclusivePointGrabber
(

)

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:
        QWheelEvent* w = getWrapped();
        QObject* res =

            w->exclusivePointGrabber(

            );

        // return type: QObject*

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

               );

    }

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

}

// Class: QWheelEvent
// Function: setExclusivePointGrabber
// Source: QSinglePointEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::setExclusivePointGrabber
(

    const QJSValue&
    a1
)

{

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

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: exclusiveGrabber (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:
        QWheelEvent* w = getWrapped();

        w->setExclusivePointGrabber(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QWheelEvent
// Function: clone
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::clone
(

)

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:
        QWheelEvent* w = getWrapped();
        QWheelEvent* res =

            w->clone(

            );

        // return type: QWheelEvent*

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

               );

    }

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

}

// Class: QWheelEvent
// Function: pixelDelta
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::pixelDelta
(

)

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:
        QWheelEvent* w = getWrapped();
        QPoint res =

            w->pixelDelta(

            );

        // return type: QPoint

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

               );

    }

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

}

// Class: QWheelEvent
// Function: angleDelta
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::angleDelta
(

)

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:
        QWheelEvent* w = getWrapped();
        QPoint res =

            w->angleDelta(

            );

        // return type: QPoint

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

               );

    }

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

}

// Class: QWheelEvent
// Function: phase
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::phase
(

)

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:
        QWheelEvent* w = getWrapped();
        Qt::ScrollPhase res =

            w->phase(

            );

        // return type: Qt::ScrollPhase

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

               );

    }

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

}

// Class: QWheelEvent
// Function: inverted
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::inverted
(

)

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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->inverted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: isInverted
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::isInverted
(

)

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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->isInverted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: hasPixelDelta
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::hasPixelDelta
(

)

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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->hasPixelDelta(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: isBeginEvent
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::isBeginEvent
(

)

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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->isBeginEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: isUpdateEvent
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::isUpdateEvent
(

)

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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->isUpdateEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: isEndEvent
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::isEndEvent
(

)

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:
        QWheelEvent* w = getWrapped();
        bool res =

            w->isEndEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QWheelEvent
// Function: source
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QWheelEvent_Wrapper::source
(

)

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:
        QWheelEvent* w = getWrapped();
        Qt::MouseEventSource res =

            w->source(

            );

        // return type: Qt::MouseEventSource

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

               );

    }

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

}


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



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

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QKeyEvent*> QKeyEvent_Wrapper::basecasters_QKeyEvent;

// static functions implementation in singleton wrapper:

// Class: QKeyEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QKeyEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

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

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


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


        // call function:

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

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

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

               );

    }

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

}

#if QT_CONFIG(shortcut)

#endif

void QKeyEvent_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

    QString fileName = ":generator/js/QKeyEvent.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:
QKeyEvent_Wrapper::QKeyEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QKeyEvent_Wrapper");
        setEngine(e);

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

*/


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

    // signal forwarding:
    initConnections();
}


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

    //qDebug() << "QKeyEvent_Wrapper::~QKeyEvent_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 QKeyEvent";

    }

}

// initialization of signal forwarding

void QKeyEvent_Wrapper::initConnections() {

    //setObjectName("QKeyEvent_Wrapper");

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


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

// Class: QKeyEvent
// Function:
// Source:
// Static: false
// Parameters: 6
// preceding Parameters: -1
QKeyEvent_Wrapper::QKeyEvent_Wrapper

(

    // RJSApi:
    QObject* h
    ,
    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3,
    const QJSValue&
    a4,
    const QJSValue&
    a5,
    const QJSValue&
    a6
)

    : RJSWrapperObj(*(RJSApi*)h)

{

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

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

        && RJSHelper::is_int(handler, a2
                            )

        && RJSHelper::is_Qt_KeyboardModifiers(handler, a3
                                             )

        && RJSHelper::is_QString(handler, a4
                                 , true

                                )

        && RJSHelper::is_bool(handler, a5
                              , true

                             )

        && RJSHelper::is_quint16(handler, a6
                                 , true

                                )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: type (QEvent::Type)

        QEvent::Type a1_cpp;

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

        // convert js parameter to cpp: key (int)

        int a2_cpp;

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

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a3_cpp;

        a3_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(handler, a3);

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

        QString a4_cpp;


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

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

        bool a5_cpp;


        if (a5.isUndefined()) {
            a5_cpp = false;
        }
        else {
            a5_cpp = RJSHelper::js2cpp_bool(handler, a5);
        }

        // convert js parameter to cpp: count (quint16)

        quint16 a6_cpp;


        if (a6.isUndefined()) {
            a6_cpp = 1;
        }
        else {
            a6_cpp = RJSHelper::js2cpp_quint16(handler, a6);
        }


        // call function:

        // construct wrapper:


        wrapped = new QKeyEvent(
            a1_cpp
            , a2_cpp
            , a3_cpp
            , a4_cpp
            , a5_cpp
            , a6_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()
        && a2.isUndefined()
        && a3.isUndefined()
        && a4.isUndefined()
        && a5.isUndefined()
        && a6.isUndefined()

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


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

}

#if QT_CONFIG(shortcut)

#endif


// non-static functions:

// Class: QKeyEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::type
(

)

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:
        QKeyEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

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

               );

    }

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

}

// Class: QKeyEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::spontaneous
(

)

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:
        QKeyEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QKeyEvent
// Function: setAccepted
// Source: QEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QKeyEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QKeyEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::isAccepted
(

)

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:
        QKeyEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QKeyEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QKeyEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

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

}

// Class: QKeyEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QKeyEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

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

}

// Class: QKeyEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::isInputEvent
(

)

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:
        QKeyEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QKeyEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::isPointerEvent
(

)

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:
        QKeyEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QKeyEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::isSinglePointEvent
(

)

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:
        QKeyEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QKeyEvent
// Function: setModifiers
// Source: QInputEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::setModifiers
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(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:
        QKeyEvent* w = getWrapped();

        w->setModifiers(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QKeyEvent
// Function: timestamp
// Source: QInputEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::timestamp
(

)

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:
        QKeyEvent* w = getWrapped();
        quint64 res =

            w->timestamp(

            );

        // return type: quint64

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

               );

    }

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

}

// Class: QKeyEvent
// Function: setTimestamp
// Source: QInputEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::setTimestamp
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: timestamp (quint64)

        quint64 a1_cpp;

        a1_cpp = RJSHelper::js2cpp_quint64(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:
        QKeyEvent* w = getWrapped();

        w->setTimestamp(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QKeyEvent
// Function: clone
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::clone
(

)

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:
        QKeyEvent* w = getWrapped();
        QKeyEvent* res =

            w->clone(

            );

        // return type: QKeyEvent*

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

               );

    }

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

}

// Class: QKeyEvent
// Function: key
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::key
(

)

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:
        QKeyEvent* w = getWrapped();
        int res =

            w->key(

            );

        // return type: int

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

               );

    }

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

}

#if QT_CONFIG(shortcut)

// Class: QKeyEvent
// Function: matches
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::matches
(

    const QJSValue&
    a1
)

const

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: key (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:
        QKeyEvent* w = getWrapped();
        bool res =

            w->matches(
                a1_cpp

            );

        // return type: bool

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

               );

    }

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

}

#endif

// Class: QKeyEvent
// Function: modifiers
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::modifiers
(

)

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:
        QKeyEvent* w = getWrapped();
        Qt::KeyboardModifiers res =

            w->modifiers(

            );

        // return type: Qt::KeyboardModifiers

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

               );

    }

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

}

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

QJSValue
QKeyEvent_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:
        QKeyEvent* 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: QKeyEvent
// Function: isAutoRepeat
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::isAutoRepeat
(

)

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:
        QKeyEvent* w = getWrapped();
        bool res =

            w->isAutoRepeat(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QKeyEvent
// Function: count
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::count
(

)

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:
        QKeyEvent* w = getWrapped();
        int res =

            w->count(

            );

        // return type: int

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

               );

    }

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

}

// Class: QKeyEvent
// Function: nativeScanCode
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::nativeScanCode
(

)

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:
        QKeyEvent* w = getWrapped();
        quint32 res =

            w->nativeScanCode(

            );

        // return type: quint32

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

               );

    }

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

}

// Class: QKeyEvent
// Function: nativeVirtualKey
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::nativeVirtualKey
(

)

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:
        QKeyEvent* w = getWrapped();
        quint32 res =

            w->nativeVirtualKey(

            );

        // return type: quint32

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

               );

    }

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

}

// Class: QKeyEvent
// Function: nativeModifiers
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QKeyEvent_Wrapper::nativeModifiers
(

)

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:
        QKeyEvent* w = getWrapped();
        quint32 res =

            w->nativeModifiers(

            );

        // return type: quint32

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

               );

    }

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

}


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



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

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QFocusEvent*> QFocusEvent_Wrapper::basecasters_QFocusEvent;

// static functions implementation in singleton wrapper:

// Class: QFocusEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QFocusEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

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

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


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


        // call function:

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

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

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

               );

    }

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

}

void QFocusEvent_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

    QString fileName = ":generator/js/QFocusEvent.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:
QFocusEvent_Wrapper::QFocusEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QFocusEvent_Wrapper");
        setEngine(e);

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

*/


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

    // signal forwarding:
    initConnections();
}


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

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

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


    if (wrappedCreated) {

        // delete wrapped object (copyable, JS ownership)
        //qDebug() << "deleting instance of QFocusEvent";
        delete wrapped;

    }

}

// initialization of signal forwarding

void QFocusEvent_Wrapper::initConnections() {

    //setObjectName("QFocusEvent_Wrapper");

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


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

// Class: QFocusEvent
// Function:
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1
QFocusEvent_Wrapper::QFocusEvent_Wrapper

(

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

    : RJSWrapperObj(*(RJSApi*)h)

{

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

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

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

                                       )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: type (QEvent::Type)

        QEvent::Type a1_cpp;

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

        // convert js parameter to cpp: reason (Qt::FocusReason)

        Qt::FocusReason a2_cpp;


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


        // call function:

        // construct wrapper:


        wrapped = new QFocusEvent(
            a1_cpp
            , a2_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()
        && a2.isUndefined()

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


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

}


// non-static functions:

// Class: QFocusEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QFocusEvent_Wrapper::type
(

)

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:
        QFocusEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

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

               );

    }

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

}

// Class: QFocusEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QFocusEvent_Wrapper::spontaneous
(

)

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:
        QFocusEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QFocusEvent
// Function: setAccepted
// Source: QEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QFocusEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QFocusEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QFocusEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QFocusEvent_Wrapper::isAccepted
(

)

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:
        QFocusEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QFocusEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QFocusEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QFocusEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

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

}

// Class: QFocusEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QFocusEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QFocusEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

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

}

// Class: QFocusEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QFocusEvent_Wrapper::isInputEvent
(

)

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:
        QFocusEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QFocusEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QFocusEvent_Wrapper::isPointerEvent
(

)

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:
        QFocusEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QFocusEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QFocusEvent_Wrapper::isSinglePointEvent
(

)

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:
        QFocusEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QFocusEvent
// Function: clone
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QFocusEvent_Wrapper::clone
(

)

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:
        QFocusEvent* w = getWrapped();
        QEvent* res =

            w->clone(

            );

        // return type: QEvent*

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

               );

    }

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

}

// Class: QFocusEvent
// Function: gotFocus
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QFocusEvent_Wrapper::gotFocus
(

)

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:
        QFocusEvent* w = getWrapped();
        bool res =

            w->gotFocus(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QFocusEvent
// Function: lostFocus
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QFocusEvent_Wrapper::lostFocus
(

)

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:
        QFocusEvent* w = getWrapped();
        bool res =

            w->lostFocus(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QFocusEvent
// Function: reason
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QFocusEvent_Wrapper::reason
(

)

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:
        QFocusEvent* w = getWrapped();
        Qt::FocusReason res =

            w->reason(

            );

        // return type: Qt::FocusReason

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

               );

    }

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

}


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



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

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QPaintEvent*> QPaintEvent_Wrapper::basecasters_QPaintEvent;

// static functions implementation in singleton wrapper:

// Class: QPaintEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QPaintEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

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

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


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


        // call function:

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

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

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

               );

    }

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

}

void QPaintEvent_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

    QString fileName = ":generator/js/QPaintEvent.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:
QPaintEvent_Wrapper::QPaintEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QPaintEvent_Wrapper");
        setEngine(e);

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

*/


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

    // signal forwarding:
    initConnections();
}


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

    //qDebug() << "QPaintEvent_Wrapper::~QPaintEvent_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 QPaintEvent";

    }

}

// initialization of signal forwarding

void QPaintEvent_Wrapper::initConnections() {

    //setObjectName("QPaintEvent_Wrapper");

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


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

// Class: QPaintEvent
// Function:
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1
QPaintEvent_Wrapper::QPaintEvent_Wrapper

(

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

    : RJSWrapperObj(*(RJSApi*)h)

{

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

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: paintRegion (QRegion)

        QRegion a1_cpp;

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


        // call function:

        // construct wrapper:


        wrapped = new QPaintEvent(
            a1_cpp

        );
        wrappedCreated = true;


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


    }

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: paintRect (QRect)

        QRect a1_cpp;

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


        // call function:

        // construct wrapper:


        wrapped = new QPaintEvent(
            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 QPaintEvent";
    wrapped = nullptr;
    wrappedCreated = false;
    handler.trace();

}


// non-static functions:

// Class: QPaintEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPaintEvent_Wrapper::type
(

)

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:
        QPaintEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

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

               );

    }

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

}

// Class: QPaintEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPaintEvent_Wrapper::spontaneous
(

)

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:
        QPaintEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPaintEvent
// Function: setAccepted
// Source: QEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QPaintEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QPaintEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QPaintEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPaintEvent_Wrapper::isAccepted
(

)

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:
        QPaintEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPaintEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPaintEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QPaintEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

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

}

// Class: QPaintEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPaintEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QPaintEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

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

}

// Class: QPaintEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPaintEvent_Wrapper::isInputEvent
(

)

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:
        QPaintEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPaintEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPaintEvent_Wrapper::isPointerEvent
(

)

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:
        QPaintEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPaintEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPaintEvent_Wrapper::isSinglePointEvent
(

)

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:
        QPaintEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QPaintEvent
// Function: clone
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPaintEvent_Wrapper::clone
(

)

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:
        QPaintEvent* w = getWrapped();
        QEvent* res =

            w->clone(

            );

        // return type: QEvent*

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

               );

    }

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

}

// Class: QPaintEvent
// Function: rect
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPaintEvent_Wrapper::rect
(

)

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:
        QPaintEvent* w = getWrapped();

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

            );

        // return type: const QRect&

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

               );

    }

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

}

// Class: QPaintEvent
// Function: region
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QPaintEvent_Wrapper::region
(

)

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:
        QPaintEvent* w = getWrapped();

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

            );

        // return type: const QRegion&

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

               );

    }

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

}


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



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

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QResizeEvent*> QResizeEvent_Wrapper::basecasters_QResizeEvent;

// static functions implementation in singleton wrapper:

// Class: QResizeEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QResizeEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

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

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


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


        // call function:

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

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

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

               );

    }

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

}

void QResizeEvent_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

    QString fileName = ":generator/js/QResizeEvent.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:
QResizeEvent_Wrapper::QResizeEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QResizeEvent_Wrapper");
        setEngine(e);

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

*/


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

    // signal forwarding:
    initConnections();
}


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

    //qDebug() << "QResizeEvent_Wrapper::~QResizeEvent_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 QResizeEvent";

    }

}

// initialization of signal forwarding

void QResizeEvent_Wrapper::initConnections() {

    //setObjectName("QResizeEvent_Wrapper");

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


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

// Class: QResizeEvent
// Function:
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1
QResizeEvent_Wrapper::QResizeEvent_Wrapper

(

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

    : RJSWrapperObj(*(RJSApi*)h)

{

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

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

        && RJSHelper::is_QSize(handler, a2
                              )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: size (QSize)

        QSize a1_cpp;

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

        // convert js parameter to cpp: oldSize (QSize)

        QSize a2_cpp;

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


        // call function:

        // construct wrapper:


        wrapped = new QResizeEvent(
            a1_cpp
            , a2_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()
        && a2.isUndefined()

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


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

}


// non-static functions:

// Class: QResizeEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QResizeEvent_Wrapper::type
(

)

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:
        QResizeEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

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

               );

    }

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

}

// Class: QResizeEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QResizeEvent_Wrapper::spontaneous
(

)

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:
        QResizeEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QResizeEvent
// Function: setAccepted
// Source: QEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QResizeEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QResizeEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QResizeEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QResizeEvent_Wrapper::isAccepted
(

)

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:
        QResizeEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QResizeEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QResizeEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QResizeEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

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

}

// Class: QResizeEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QResizeEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QResizeEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

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

}

// Class: QResizeEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QResizeEvent_Wrapper::isInputEvent
(

)

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:
        QResizeEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QResizeEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QResizeEvent_Wrapper::isPointerEvent
(

)

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:
        QResizeEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QResizeEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QResizeEvent_Wrapper::isSinglePointEvent
(

)

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:
        QResizeEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QResizeEvent
// Function: clone
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QResizeEvent_Wrapper::clone
(

)

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:
        QResizeEvent* w = getWrapped();
        QEvent* res =

            w->clone(

            );

        // return type: QEvent*

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

               );

    }

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

}

// Class: QResizeEvent
// Function: size
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QResizeEvent_Wrapper::size
(

)

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:
        QResizeEvent* w = getWrapped();

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

            );

        // return type: const QSize&

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

               );

    }

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

}

// Class: QResizeEvent
// Function: oldSize
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QResizeEvent_Wrapper::oldSize
(

)

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:
        QResizeEvent* w = getWrapped();

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

            );

        // return type: const QSize&

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

               );

    }

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

}


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



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

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QDragEnterEvent*> QDragEnterEvent_Wrapper::basecasters_QDragEnterEvent;

// static functions implementation in singleton wrapper:

// Class: QDragEnterEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDragEnterEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

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

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


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


        // call function:

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

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

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

               );

    }

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

}

void QDragEnterEvent_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

    QString fileName = ":generator/js/QDragEnterEvent.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:
QDragEnterEvent_Wrapper::QDragEnterEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QDragEnterEvent_Wrapper");
        setEngine(e);

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

*/


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

    // signal forwarding:
    initConnections();
}


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

    //qDebug() << "QDragEnterEvent_Wrapper::~QDragEnterEvent_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 QDragEnterEvent";

    }

}

// initialization of signal forwarding

void QDragEnterEvent_Wrapper::initConnections() {

    //setObjectName("QDragEnterEvent_Wrapper");

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


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

// Class: QDragEnterEvent
// Function:
// Source:
// Static: false
// Parameters: 5
// preceding Parameters: -1
QDragEnterEvent_Wrapper::QDragEnterEvent_Wrapper

(

    // RJSApi:
    QObject* h
    ,
    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3,
    const QJSValue&
    a4,
    const QJSValue&
    a5
)

    : RJSWrapperObj(*(RJSApi*)h)

{

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

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

        && RJSHelper::is_Qt_DropActions(handler, a2
                                       )

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

                                      )

        && RJSHelper::is_Qt_MouseButtons(handler, a4
                                        )

        && RJSHelper::is_Qt_KeyboardModifiers(handler, a5
                                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: point (QPoint)

        QPoint a1_cpp;

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

        // convert js parameter to cpp: actions (Qt::DropActions)

        Qt::DropActions a2_cpp;

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

        // convert js parameter to cpp: data (QMimeData)


        // pointer:
        QMimeData*
        a3_cpp;

        a3_cpp = RJSHelper::js2cpp_QMimeData_ptr(handler, a3);

        // convert js parameter to cpp: buttons (Qt::MouseButtons)

        Qt::MouseButtons a4_cpp;

        a4_cpp = RJSHelper::js2cpp_Qt_MouseButtons(handler, a4);

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a5_cpp;

        a5_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(handler, a5);


        // call function:

        // construct wrapper:


        wrapped = new QDragEnterEvent(
            a1_cpp
            , a2_cpp
            , a3_cpp
            , a4_cpp
            , a5_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()
        && a2.isUndefined()
        && a3.isUndefined()
        && a4.isUndefined()
        && a5.isUndefined()

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


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

}


// non-static functions:

// Class: QDragEnterEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::type
(

)

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:
        QDragEnterEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

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

               );

    }

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

}

// Class: QDragEnterEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::spontaneous
(

)

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:
        QDragEnterEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QDragEnterEvent
// Function: setAccepted
// Source: QEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QDragEnterEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QDragEnterEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::isAccepted
(

)

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:
        QDragEnterEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QDragEnterEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::isInputEvent
(

)

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:
        QDragEnterEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QDragEnterEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::isPointerEvent
(

)

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:
        QDragEnterEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QDragEnterEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::isSinglePointEvent
(

)

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:
        QDragEnterEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QDragEnterEvent
// Function: position
// Source: QDropEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::position
(

)

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:
        QDragEnterEvent* w = getWrapped();
        QPointF res =

            w->position(

            );

        // return type: QPointF

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

               );

    }

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

}

// Class: QDragEnterEvent
// Function: buttons
// Source: QDropEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::buttons
(

)

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:
        QDragEnterEvent* w = getWrapped();
        Qt::MouseButtons res =

            w->buttons(

            );

        // return type: Qt::MouseButtons

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

               );

    }

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

}

// Class: QDragEnterEvent
// Function: modifiers
// Source: QDropEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::modifiers
(

)

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:
        QDragEnterEvent* w = getWrapped();
        Qt::KeyboardModifiers res =

            w->modifiers(

            );

        // return type: Qt::KeyboardModifiers

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

               );

    }

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

}

// Class: QDragEnterEvent
// Function: acceptProposedAction
// Source: QDropEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::acceptProposedAction
(

)

{

    {


        // 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:
        QDragEnterEvent* w = getWrapped();

        w->acceptProposedAction(

        );

        return QJSValue();

    }

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

}

// Class: QDragEnterEvent
// Function: setDropAction
// Source: QDropEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::setDropAction
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: action (Qt::DropAction)

        Qt::DropAction a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_DropAction(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:
        QDragEnterEvent* w = getWrapped();

        w->setDropAction(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QDragEnterEvent
// Function: source
// Source: QDropEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::source
(

)

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:
        QDragEnterEvent* w = getWrapped();
        QObject* res =

            w->source(

            );

        // return type: QObject*

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

               );

    }

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

}

// Class: QDragEnterEvent
// Function: mimeData
// Source: QDropEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::mimeData
(

)

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:
        QDragEnterEvent* w = getWrapped();
        const QMimeData* res =

            w->mimeData(

            );

        // return type: const QMimeData*

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

               );

    }

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

}

// Class: QDragEnterEvent
// Function: clone
// Source: QDragMoveEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::clone
(

)

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:
        QDragEnterEvent* w = getWrapped();
        QDragMoveEvent* res =

            w->clone(

            );

        // return type: QDragMoveEvent*

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

               );

    }

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

}

// Class: QDragEnterEvent
// Function: answerRect
// Source: QDragMoveEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::answerRect
(

)

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:
        QDragEnterEvent* w = getWrapped();
        QRect res =

            w->answerRect(

            );

        // return type: QRect

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

               );

    }

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

}

// Class: QDragEnterEvent
// Function: accept
// Source: QDragMoveEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::accept
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: r (QRect)

        QRect a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QRect(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:
        QDragEnterEvent* w = getWrapped();

        w->accept(
            a1_cpp

        );

        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:
        QDragEnterEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

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

}

// Class: QDragEnterEvent
// Function: ignore
// Source: QDragMoveEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDragEnterEvent_Wrapper::ignore
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: r (QRect)

        QRect a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QRect(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:
        QDragEnterEvent* w = getWrapped();

        w->ignore(
            a1_cpp

        );

        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:
        QDragEnterEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

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

}


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



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

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QDropEvent*> QDropEvent_Wrapper::basecasters_QDropEvent;

// static functions implementation in singleton wrapper:

// Class: QDropEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDropEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

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

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


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


        // call function:

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

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

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

               );

    }

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

}

void QDropEvent_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

    QString fileName = ":generator/js/QDropEvent.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:
QDropEvent_Wrapper::QDropEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QDropEvent_Wrapper");
        setEngine(e);

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

*/


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

    // signal forwarding:
    initConnections();
}


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

    //qDebug() << "QDropEvent_Wrapper::~QDropEvent_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 QDropEvent";

    }

}

// initialization of signal forwarding

void QDropEvent_Wrapper::initConnections() {

    //setObjectName("QDropEvent_Wrapper");

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


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

// Class: QDropEvent
// Function:
// Source:
// Static: false
// Parameters: 6
// preceding Parameters: -1
QDropEvent_Wrapper::QDropEvent_Wrapper

(

    // RJSApi:
    QObject* h
    ,
    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3,
    const QJSValue&
    a4,
    const QJSValue&
    a5,
    const QJSValue&
    a6
)

    : RJSWrapperObj(*(RJSApi*)h)

{

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

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

        && RJSHelper::is_Qt_DropActions(handler, a2
                                       )

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

                                      )

        && RJSHelper::is_Qt_MouseButtons(handler, a4
                                        )

        && RJSHelper::is_Qt_KeyboardModifiers(handler, a5
                                             )

        && RJSHelper::is_QEvent_Type(handler, a6
                                     , true

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: pos (QPointF)

        QPointF a1_cpp;

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

        // convert js parameter to cpp: actions (Qt::DropActions)

        Qt::DropActions a2_cpp;

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

        // convert js parameter to cpp: data (QMimeData)


        // pointer:
        QMimeData*
        a3_cpp;

        a3_cpp = RJSHelper::js2cpp_QMimeData_ptr(handler, a3);

        // convert js parameter to cpp: buttons (Qt::MouseButtons)

        Qt::MouseButtons a4_cpp;

        a4_cpp = RJSHelper::js2cpp_Qt_MouseButtons(handler, a4);

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a5_cpp;

        a5_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(handler, a5);

        // convert js parameter to cpp: type (QEvent::Type)

        QEvent::Type a6_cpp;


        if (a6.isUndefined()) {
            a6_cpp = QEvent::Drop;
        }
        else {
            a6_cpp = RJSHelper::js2cpp_QEvent_Type(handler, a6);
        }


        // call function:

        // construct wrapper:


        wrapped = new QDropEvent(
            a1_cpp
            , a2_cpp
            , a3_cpp
            , a4_cpp
            , a5_cpp
            , a6_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()
        && a2.isUndefined()
        && a3.isUndefined()
        && a4.isUndefined()
        && a5.isUndefined()
        && a6.isUndefined()

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


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

}


// non-static functions:

// Class: QDropEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::type
(

)

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:
        QDropEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

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

               );

    }

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

}

// Class: QDropEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::spontaneous
(

)

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:
        QDropEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QDropEvent
// Function: setAccepted
// Source: QEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QDropEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QDropEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::isAccepted
(

)

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:
        QDropEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QDropEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QDropEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

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

}

// Class: QDropEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QDropEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

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

}

// Class: QDropEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::isInputEvent
(

)

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:
        QDropEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QDropEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::isPointerEvent
(

)

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:
        QDropEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QDropEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::isSinglePointEvent
(

)

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:
        QDropEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QDropEvent
// Function: clone
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::clone
(

)

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:
        QDropEvent* w = getWrapped();
        QEvent* res =

            w->clone(

            );

        // return type: QEvent*

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

               );

    }

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

}

// Class: QDropEvent
// Function: position
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::position
(

)

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:
        QDropEvent* w = getWrapped();
        QPointF res =

            w->position(

            );

        // return type: QPointF

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

               );

    }

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

}

// Class: QDropEvent
// Function: buttons
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::buttons
(

)

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:
        QDropEvent* w = getWrapped();
        Qt::MouseButtons res =

            w->buttons(

            );

        // return type: Qt::MouseButtons

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

               );

    }

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

}

// Class: QDropEvent
// Function: modifiers
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::modifiers
(

)

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:
        QDropEvent* w = getWrapped();
        Qt::KeyboardModifiers res =

            w->modifiers(

            );

        // return type: Qt::KeyboardModifiers

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

               );

    }

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

}

// Class: QDropEvent
// Function: acceptProposedAction
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::acceptProposedAction
(

)

{

    {


        // 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:
        QDropEvent* w = getWrapped();

        w->acceptProposedAction(

        );

        return QJSValue();

    }

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

}

// Class: QDropEvent
// Function: setDropAction
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::setDropAction
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: action (Qt::DropAction)

        Qt::DropAction a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_DropAction(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:
        QDropEvent* w = getWrapped();

        w->setDropAction(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QDropEvent
// Function: source
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::source
(

)

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:
        QDropEvent* w = getWrapped();
        QObject* res =

            w->source(

            );

        // return type: QObject*

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

               );

    }

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

}

// Class: QDropEvent
// Function: mimeData
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDropEvent_Wrapper::mimeData
(

)

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:
        QDropEvent* w = getWrapped();
        const QMimeData* res =

            w->mimeData(

            );

        // return type: const QMimeData*

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

               );

    }

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

}


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



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

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QContextMenuEvent*> QContextMenuEvent_Wrapper::basecasters_QContextMenuEvent;

// static functions implementation in singleton wrapper:

// Class: QContextMenuEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QContextMenuEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

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

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


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


        // call function:

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

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

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

               );

    }

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

}

void QContextMenuEvent_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

    // create instance of singleton wrapper for static functions:
    QContextMenuEvent_WrapperSingleton * s = new QContextMenuEvent_WrapperSingleton(handler);
    engine->globalObject().setProperty("QContextMenuEvent_WrapperSingletonInstance", engine->newQObject(s));
    QJSEngine::setObjectOwnership(s, QJSEngine::CppOwnership);

    QString fileName = ":generator/js/QContextMenuEvent.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:
QContextMenuEvent_Wrapper::QContextMenuEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QContextMenuEvent_Wrapper");
        setEngine(e);

        // signal forwarding:
        //initConnections();
      }

*/


// special constructor to wrap existing object:
QContextMenuEvent_Wrapper::QContextMenuEvent_Wrapper(RJSApi& h, QContextMenuEvent* o, bool wrappedCreated) : RJSWrapperObj(h), wrapped(o), wrappedCreated(wrappedCreated) {
    //RDebug::incCounter(QString("QContextMenuEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::incCounter(QString("QContextMenuEvent_Wrapper"));
    //setObjectName("QContextMenuEvent_Wrapper");
    //setHandler(h);

    // signal forwarding:
    initConnections();
}


// destructor:
QContextMenuEvent_Wrapper::~QContextMenuEvent_Wrapper() {
    //RDebug::decCounter(QString("QContextMenuEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::decCounter(QString("QContextMenuEvent_Wrapper"));

    //qDebug() << "QContextMenuEvent_Wrapper::~QContextMenuEvent_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 QContextMenuEvent";

    }

}

// initialization of signal forwarding

void QContextMenuEvent_Wrapper::initConnections() {

    //setObjectName("QContextMenuEvent_Wrapper");

    // tell script handler that this wrapper needs to be deleted if the engine is deleted:
    handler.registerWrapper(*this);


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

// Class: QContextMenuEvent
// Function:
// Source:
// Static: false
// Parameters: 4
// preceding Parameters: -1
QContextMenuEvent_Wrapper::QContextMenuEvent_Wrapper

(

    // RJSApi:
    QObject* h
    ,
    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3,
    const QJSValue&
    a4
)

    : RJSWrapperObj(*(RJSApi*)h)

{

    //RDebug::incCounter(QString("QContextMenuEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::incCounter(QString("QContextMenuEvent_Wrapper"));

    // check parameter types:
    if (
        RJSHelper::is_QContextMenuEvent_Reason(handler, a1
                                              )

        && RJSHelper::is_QPoint(handler, a2
                               )

        && RJSHelper::is_QPoint(handler, a3
                               )

        && RJSHelper::is_Qt_KeyboardModifiers(handler, a4
                , true

                                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: reason (QContextMenuEvent::Reason)

        QContextMenuEvent::Reason a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QContextMenuEvent_Reason(handler, a1);

        // convert js parameter to cpp: pos (QPoint)

        QPoint a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QPoint(handler, a2);

        // convert js parameter to cpp: globalPos (QPoint)

        QPoint a3_cpp;

        a3_cpp = RJSHelper::js2cpp_QPoint(handler, a3);

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a4_cpp;


        if (a4.isUndefined()) {
            a4_cpp = Qt::NoModifier;
        }
        else {
            a4_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(handler, a4);
        }


        // call function:

        // construct wrapper:


        wrapped = new QContextMenuEvent(
            a1_cpp
            , a2_cpp
            , a3_cpp
            , a4_cpp

        );
        wrappedCreated = true;


        // signal forwarding:
        // TODO
        //connect(wrapped, SIGNAL(triggered(bool)), this, SLOT(triggeredEmitter(bool)));
        initConnections();
        return;


    }

    // check parameter types:
    if (
        RJSHelper::is_QContextMenuEvent_Reason(handler, a1
                                              )

        && RJSHelper::is_QPoint(handler, a2
                               )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: reason (QContextMenuEvent::Reason)

        QContextMenuEvent::Reason a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QContextMenuEvent_Reason(handler, a1);

        // convert js parameter to cpp: pos (QPoint)

        QPoint a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QPoint(handler, a2);


        // call function:

        // construct wrapper:


        wrapped = new QContextMenuEvent(
            a1_cpp
            , a2_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()
        && a2.isUndefined()
        && a3.isUndefined()
        && a4.isUndefined()

    ) {
        wrapped = nullptr;
        wrappedCreated = false;
        return;
    }


    qWarning() << "no matching constructor variant found for QContextMenuEvent";
    wrapped = nullptr;
    wrappedCreated = false;
    handler.trace();

}


// non-static functions:

// Class: QContextMenuEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::type
(

)

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:
        QContextMenuEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

        return RJSHelper::cpp2js_QEvent_Type(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for type";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::spontaneous
(

)

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:
        QContextMenuEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for spontaneous";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: setAccepted
// Source: QEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QContextMenuEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAccepted";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::isAccepted
(

)

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:
        QContextMenuEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isAccepted";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QContextMenuEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for accept";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QContextMenuEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for ignore";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::isInputEvent
(

)

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:
        QContextMenuEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isInputEvent";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::isPointerEvent
(

)

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:
        QContextMenuEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isPointerEvent";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::isSinglePointEvent
(

)

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:
        QContextMenuEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isSinglePointEvent";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: modifiers
// Source: QInputEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::modifiers
(

)

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:
        QContextMenuEvent* w = getWrapped();
        Qt::KeyboardModifiers res =

            w->modifiers(

            );

        // return type: Qt::KeyboardModifiers

        return RJSHelper::cpp2js_Qt_KeyboardModifiers(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for modifiers";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: setModifiers
// Source: QInputEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::setModifiers
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_KeyboardModifiers(handler, a1
                                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(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:
        QContextMenuEvent* w = getWrapped();

        w->setModifiers(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setModifiers";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: timestamp
// Source: QInputEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::timestamp
(

)

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:
        QContextMenuEvent* w = getWrapped();
        quint64 res =

            w->timestamp(

            );

        // return type: quint64

        return RJSHelper::cpp2js_quint64(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for timestamp";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: setTimestamp
// Source: QInputEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::setTimestamp
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_quint64(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: timestamp (quint64)

        quint64 a1_cpp;

        a1_cpp = RJSHelper::js2cpp_quint64(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:
        QContextMenuEvent* w = getWrapped();

        w->setTimestamp(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setTimestamp";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: clone
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::clone
(

)

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:
        QContextMenuEvent* w = getWrapped();
        QContextMenuEvent* res =

            w->clone(

            );

        // return type: QContextMenuEvent*

        return RJSHelper::cpp2js_QContextMenuEvent(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for clone";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: x
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::x
(

)

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:
        QContextMenuEvent* w = getWrapped();
        int res =

            w->x(

            );

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for x";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: y
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::y
(

)

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:
        QContextMenuEvent* w = getWrapped();
        int res =

            w->y(

            );

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for y";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: globalX
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::globalX
(

)

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:
        QContextMenuEvent* w = getWrapped();
        int res =

            w->globalX(

            );

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for globalX";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: globalY
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::globalY
(

)

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:
        QContextMenuEvent* w = getWrapped();
        int res =

            w->globalY(

            );

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for globalY";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: pos
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::pos
(

)

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:
        QContextMenuEvent* w = getWrapped();

        // return type is reference:
        // use pointer instead 3:
        const QPoint* res =
            &
            w->pos(

            );

        // return type: const QPoint&

        return RJSHelper::cpp2js_QPoint(
                   handler,
                   // non-copyable: false
                   // return type is reference, type is copyable:
                   // convert pointer back to reference:
                   *res

               );

    }

    qWarning() << "no matching function variant found for pos";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: globalPos
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::globalPos
(

)

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:
        QContextMenuEvent* w = getWrapped();

        // return type is reference:
        // use pointer instead 3:
        const QPoint* res =
            &
            w->globalPos(

            );

        // return type: const QPoint&

        return RJSHelper::cpp2js_QPoint(
                   handler,
                   // non-copyable: false
                   // return type is reference, type is copyable:
                   // convert pointer back to reference:
                   *res

               );

    }

    qWarning() << "no matching function variant found for globalPos";
    handler.trace();
    return QJSValue();

}

// Class: QContextMenuEvent
// Function: reason
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QContextMenuEvent_Wrapper::reason
(

)

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:
        QContextMenuEvent* w = getWrapped();
        QContextMenuEvent::Reason res =

            w->reason(

            );

        // return type: QContextMenuEvent::Reason

        return RJSHelper::cpp2js_QContextMenuEvent_Reason(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for reason";
    handler.trace();
    return QJSValue();

}


// member functions for static properties, forward to static function



// protected overwritten functions / events and their public invokable counterparts:

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QDragMoveEvent*> QDragMoveEvent_Wrapper::basecasters_QDragMoveEvent;

// static functions implementation in singleton wrapper:

// Class: QDragMoveEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDragMoveEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                          , true

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


        if (a1.isUndefined()) {
            a1_cpp = -1;
        }
        else {
            a1_cpp = RJSHelper::js2cpp_int(handler, a1);
        }


        // call function:

        // static member function:
        // call base class static function:
        int res =

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for registerEventType";
    handler.trace();
    return QJSValue();

}

void QDragMoveEvent_Wrapper::init(RJSApi& handler) {

    //qmlRegisterType<QDragMoveEvent_Wrapper>("org.qcad", 1, 0, "QDragMoveEvent_Wrapper");
    qmlRegisterInterface<QDragMoveEvent_Wrapper>("QDragMoveEvent_Wrapper", 1);


    QJSEngine* engine = handler.getEngine();


    // make type scriptable for JS files:
    QJSValue global = engine->globalObject();
    RJSType_QDragMoveEvent* t = new RJSType_QDragMoveEvent();
    global.setProperty("RJSType_QDragMoveEvent", engine->newQObject(t));

    // initialize ID for this type:
    RJSType_QDragMoveEvent::getIdStatic();



    // wrapper:
    QJSValue mo = engine->newQMetaObject(&QDragMoveEvent_Wrapper::staticMetaObject);
    engine->globalObject().setProperty("QDragMoveEvent_Wrapper", mo);



    // JS base class:
    //QJSValue mob = engine->newQMetaObject(&QDragMoveEvent_BaseJs::staticMetaObject);
    //engine->globalObject().setProperty("QDragMoveEvent_BaseJs", mob);

    // singleton wrapper:
    QJSValue mos = engine->newQMetaObject(&QDragMoveEvent_WrapperSingleton::staticMetaObject);
    engine->globalObject().setProperty("QDragMoveEvent_WrapperSingleton", mos);

    // create instance of singleton wrapper for static functions:
    QDragMoveEvent_WrapperSingleton * s = new QDragMoveEvent_WrapperSingleton(handler);
    engine->globalObject().setProperty("QDragMoveEvent_WrapperSingletonInstance", engine->newQObject(s));
    QJSEngine::setObjectOwnership(s, QJSEngine::CppOwnership);

    QString fileName = ":generator/js/QDragMoveEvent.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:
QDragMoveEvent_Wrapper::QDragMoveEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QDragMoveEvent_Wrapper");
        setEngine(e);

        // signal forwarding:
        //initConnections();
      }

*/


// special constructor to wrap existing object:
QDragMoveEvent_Wrapper::QDragMoveEvent_Wrapper(RJSApi& h, QDragMoveEvent* o, bool wrappedCreated) : RJSWrapperObj(h), wrapped(o), wrappedCreated(wrappedCreated) {
    //RDebug::incCounter(QString("QDragMoveEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::incCounter(QString("QDragMoveEvent_Wrapper"));
    //setObjectName("QDragMoveEvent_Wrapper");
    //setHandler(h);

    // signal forwarding:
    initConnections();
}


// destructor:
QDragMoveEvent_Wrapper::~QDragMoveEvent_Wrapper() {
    //RDebug::decCounter(QString("QDragMoveEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::decCounter(QString("QDragMoveEvent_Wrapper"));

    //qDebug() << "QDragMoveEvent_Wrapper::~QDragMoveEvent_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 QDragMoveEvent";

    }

}

// initialization of signal forwarding

void QDragMoveEvent_Wrapper::initConnections() {

    //setObjectName("QDragMoveEvent_Wrapper");

    // tell script handler that this wrapper needs to be deleted if the engine is deleted:
    handler.registerWrapper(*this);


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

// Class: QDragMoveEvent
// Function:
// Source:
// Static: false
// Parameters: 6
// preceding Parameters: -1
QDragMoveEvent_Wrapper::QDragMoveEvent_Wrapper

(

    // RJSApi:
    QObject* h
    ,
    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3,
    const QJSValue&
    a4,
    const QJSValue&
    a5,
    const QJSValue&
    a6
)

    : RJSWrapperObj(*(RJSApi*)h)

{

    //RDebug::incCounter(QString("QDragMoveEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::incCounter(QString("QDragMoveEvent_Wrapper"));

    // check parameter types:
    if (
        RJSHelper::is_QPoint(handler, a1
                            )

        && RJSHelper::is_Qt_DropActions(handler, a2
                                       )

        && RJSHelper::is_QMimeData_ptr(handler, a3
                                       , true

                                      )

        && RJSHelper::is_Qt_MouseButtons(handler, a4
                                        )

        && RJSHelper::is_Qt_KeyboardModifiers(handler, a5
                                             )

        && RJSHelper::is_QEvent_Type(handler, a6
                                     , true

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: pos (QPoint)

        QPoint a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QPoint(handler, a1);

        // convert js parameter to cpp: actions (Qt::DropActions)

        Qt::DropActions a2_cpp;

        a2_cpp = RJSHelper::js2cpp_Qt_DropActions(handler, a2);

        // convert js parameter to cpp: data (QMimeData)


        // pointer:
        QMimeData*
        a3_cpp;

        a3_cpp = RJSHelper::js2cpp_QMimeData_ptr(handler, a3);

        // convert js parameter to cpp: buttons (Qt::MouseButtons)

        Qt::MouseButtons a4_cpp;

        a4_cpp = RJSHelper::js2cpp_Qt_MouseButtons(handler, a4);

        // convert js parameter to cpp: modifiers (Qt::KeyboardModifiers)

        Qt::KeyboardModifiers a5_cpp;

        a5_cpp = RJSHelper::js2cpp_Qt_KeyboardModifiers(handler, a5);

        // convert js parameter to cpp: type (QEvent::Type)

        QEvent::Type a6_cpp;


        if (a6.isUndefined()) {
            a6_cpp = QDragMoveEvent::DragMove;
        }
        else {
            a6_cpp = RJSHelper::js2cpp_QEvent_Type(handler, a6);
        }


        // call function:

        // construct wrapper:


        wrapped = new QDragMoveEvent(
            a1_cpp
            , a2_cpp
            , a3_cpp
            , a4_cpp
            , a5_cpp
            , a6_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()
        && a2.isUndefined()
        && a3.isUndefined()
        && a4.isUndefined()
        && a5.isUndefined()
        && a6.isUndefined()

    ) {
        wrapped = nullptr;
        wrappedCreated = false;
        return;
    }


    qWarning() << "no matching constructor variant found for QDragMoveEvent";
    wrapped = nullptr;
    wrappedCreated = false;
    handler.trace();

}


// non-static functions:

// Class: QDragMoveEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::type
(

)

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:
        QDragMoveEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

        return RJSHelper::cpp2js_QEvent_Type(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for type";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::spontaneous
(

)

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:
        QDragMoveEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for spontaneous";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: setAccepted
// Source: QEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QDragMoveEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAccepted";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::isAccepted
(

)

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:
        QDragMoveEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isAccepted";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::isInputEvent
(

)

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:
        QDragMoveEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isInputEvent";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::isPointerEvent
(

)

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:
        QDragMoveEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isPointerEvent";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::isSinglePointEvent
(

)

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:
        QDragMoveEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isSinglePointEvent";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: position
// Source: QDropEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::position
(

)

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:
        QDragMoveEvent* w = getWrapped();
        QPointF res =

            w->position(

            );

        // return type: QPointF

        return RJSHelper::cpp2js_QPointF(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for position";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: buttons
// Source: QDropEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::buttons
(

)

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:
        QDragMoveEvent* w = getWrapped();
        Qt::MouseButtons res =

            w->buttons(

            );

        // return type: Qt::MouseButtons

        return RJSHelper::cpp2js_Qt_MouseButtons(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for buttons";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: modifiers
// Source: QDropEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::modifiers
(

)

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:
        QDragMoveEvent* w = getWrapped();
        Qt::KeyboardModifiers res =

            w->modifiers(

            );

        // return type: Qt::KeyboardModifiers

        return RJSHelper::cpp2js_Qt_KeyboardModifiers(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for modifiers";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: acceptProposedAction
// Source: QDropEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::acceptProposedAction
(

)

{

    {


        // 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:
        QDragMoveEvent* w = getWrapped();

        w->acceptProposedAction(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for acceptProposedAction";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: setDropAction
// Source: QDropEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::setDropAction
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_DropAction(handler, a1
                                   )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: action (Qt::DropAction)

        Qt::DropAction a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_DropAction(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:
        QDragMoveEvent* w = getWrapped();

        w->setDropAction(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setDropAction";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: source
// Source: QDropEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::source
(

)

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:
        QDragMoveEvent* w = getWrapped();
        QObject* res =

            w->source(

            );

        // return type: QObject*

        return RJSHelper::cpp2js_QObject(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for source";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: mimeData
// Source: QDropEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::mimeData
(

)

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:
        QDragMoveEvent* w = getWrapped();
        const QMimeData* res =

            w->mimeData(

            );

        // return type: const QMimeData*

        return RJSHelper::cpp2js_QMimeData(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for mimeData";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: clone
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::clone
(

)

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:
        QDragMoveEvent* w = getWrapped();
        QDragMoveEvent* res =

            w->clone(

            );

        // return type: QDragMoveEvent*

        return RJSHelper::cpp2js_QDragMoveEvent(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for clone";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: answerRect
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::answerRect
(

)

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:
        QDragMoveEvent* w = getWrapped();
        QRect res =

            w->answerRect(

            );

        // return type: QRect

        return RJSHelper::cpp2js_QRect(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for answerRect";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: accept
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::accept
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QRect(handler, a1
                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: r (QRect)

        QRect a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QRect(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:
        QDragMoveEvent* w = getWrapped();

        w->accept(
            a1_cpp

        );

        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:
        QDragMoveEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for accept";
    handler.trace();
    return QJSValue();

}

// Class: QDragMoveEvent
// Function: ignore
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDragMoveEvent_Wrapper::ignore
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QRect(handler, a1
                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: r (QRect)

        QRect a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QRect(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:
        QDragMoveEvent* w = getWrapped();

        w->ignore(
            a1_cpp

        );

        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:
        QDragMoveEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for ignore";
    handler.trace();
    return QJSValue();

}


// member functions for static properties, forward to static function



// protected overwritten functions / events and their public invokable counterparts:

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QDragLeaveEvent*> QDragLeaveEvent_Wrapper::basecasters_QDragLeaveEvent;

// static functions implementation in singleton wrapper:

// Class: QDragLeaveEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDragLeaveEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                          , true

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


        if (a1.isUndefined()) {
            a1_cpp = -1;
        }
        else {
            a1_cpp = RJSHelper::js2cpp_int(handler, a1);
        }


        // call function:

        // static member function:
        // call base class static function:
        int res =

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for registerEventType";
    handler.trace();
    return QJSValue();

}

void QDragLeaveEvent_Wrapper::init(RJSApi& handler) {

    //qmlRegisterType<QDragLeaveEvent_Wrapper>("org.qcad", 1, 0, "QDragLeaveEvent_Wrapper");
    qmlRegisterInterface<QDragLeaveEvent_Wrapper>("QDragLeaveEvent_Wrapper", 1);


    QJSEngine* engine = handler.getEngine();


    // make type scriptable for JS files:
    QJSValue global = engine->globalObject();
    RJSType_QDragLeaveEvent* t = new RJSType_QDragLeaveEvent();
    global.setProperty("RJSType_QDragLeaveEvent", engine->newQObject(t));

    // initialize ID for this type:
    RJSType_QDragLeaveEvent::getIdStatic();



    // wrapper:
    QJSValue mo = engine->newQMetaObject(&QDragLeaveEvent_Wrapper::staticMetaObject);
    engine->globalObject().setProperty("QDragLeaveEvent_Wrapper", mo);



    // JS base class:
    //QJSValue mob = engine->newQMetaObject(&QDragLeaveEvent_BaseJs::staticMetaObject);
    //engine->globalObject().setProperty("QDragLeaveEvent_BaseJs", mob);

    // singleton wrapper:
    QJSValue mos = engine->newQMetaObject(&QDragLeaveEvent_WrapperSingleton::staticMetaObject);
    engine->globalObject().setProperty("QDragLeaveEvent_WrapperSingleton", mos);

    // create instance of singleton wrapper for static functions:
    QDragLeaveEvent_WrapperSingleton * s = new QDragLeaveEvent_WrapperSingleton(handler);
    engine->globalObject().setProperty("QDragLeaveEvent_WrapperSingletonInstance", engine->newQObject(s));
    QJSEngine::setObjectOwnership(s, QJSEngine::CppOwnership);

    QString fileName = ":generator/js/QDragLeaveEvent.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:
QDragLeaveEvent_Wrapper::QDragLeaveEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QDragLeaveEvent_Wrapper");
        setEngine(e);

        // signal forwarding:
        //initConnections();
      }

*/


// special constructor to wrap existing object:
QDragLeaveEvent_Wrapper::QDragLeaveEvent_Wrapper(RJSApi& h, QDragLeaveEvent* o, bool wrappedCreated) : RJSWrapperObj(h), wrapped(o), wrappedCreated(wrappedCreated) {
    //RDebug::incCounter(QString("QDragLeaveEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::incCounter(QString("QDragLeaveEvent_Wrapper"));
    //setObjectName("QDragLeaveEvent_Wrapper");
    //setHandler(h);

    // signal forwarding:
    initConnections();
}


// destructor:
QDragLeaveEvent_Wrapper::~QDragLeaveEvent_Wrapper() {
    //RDebug::decCounter(QString("QDragLeaveEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::decCounter(QString("QDragLeaveEvent_Wrapper"));

    //qDebug() << "QDragLeaveEvent_Wrapper::~QDragLeaveEvent_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 QDragLeaveEvent";

    }

}

// initialization of signal forwarding

void QDragLeaveEvent_Wrapper::initConnections() {

    //setObjectName("QDragLeaveEvent_Wrapper");

    // tell script handler that this wrapper needs to be deleted if the engine is deleted:
    handler.registerWrapper(*this);


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

// Class: QDragLeaveEvent
// Function:
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1
QDragLeaveEvent_Wrapper::QDragLeaveEvent_Wrapper

(

    // RJSApi:
    QObject* h

)

    : RJSWrapperObj(*(RJSApi*)h)

{

    //RDebug::incCounter(QString("QDragLeaveEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::incCounter(QString("QDragLeaveEvent_Wrapper"));

    {


        // call function:

        // construct wrapper:


        wrapped = new QDragLeaveEvent(

        );
        wrappedCreated = true;


        // signal forwarding:
        // TODO
        //connect(wrapped, SIGNAL(triggered(bool)), this, SLOT(triggeredEmitter(bool)));
        initConnections();
        return;


    }


    qWarning() << "no matching constructor variant found for QDragLeaveEvent";
    wrapped = nullptr;
    wrappedCreated = false;
    handler.trace();

}


// non-static functions:

// Class: QDragLeaveEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragLeaveEvent_Wrapper::type
(

)

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:
        QDragLeaveEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

        return RJSHelper::cpp2js_QEvent_Type(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for type";
    handler.trace();
    return QJSValue();

}

// Class: QDragLeaveEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragLeaveEvent_Wrapper::spontaneous
(

)

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:
        QDragLeaveEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for spontaneous";
    handler.trace();
    return QJSValue();

}

// Class: QDragLeaveEvent
// Function: setAccepted
// Source: QEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QDragLeaveEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QDragLeaveEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAccepted";
    handler.trace();
    return QJSValue();

}

// Class: QDragLeaveEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragLeaveEvent_Wrapper::isAccepted
(

)

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:
        QDragLeaveEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isAccepted";
    handler.trace();
    return QJSValue();

}

// Class: QDragLeaveEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragLeaveEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QDragLeaveEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for accept";
    handler.trace();
    return QJSValue();

}

// Class: QDragLeaveEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragLeaveEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QDragLeaveEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for ignore";
    handler.trace();
    return QJSValue();

}

// Class: QDragLeaveEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragLeaveEvent_Wrapper::isInputEvent
(

)

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:
        QDragLeaveEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isInputEvent";
    handler.trace();
    return QJSValue();

}

// Class: QDragLeaveEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragLeaveEvent_Wrapper::isPointerEvent
(

)

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:
        QDragLeaveEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isPointerEvent";
    handler.trace();
    return QJSValue();

}

// Class: QDragLeaveEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragLeaveEvent_Wrapper::isSinglePointEvent
(

)

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:
        QDragLeaveEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isSinglePointEvent";
    handler.trace();
    return QJSValue();

}

// Class: QDragLeaveEvent
// Function: clone
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QDragLeaveEvent_Wrapper::clone
(

)

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:
        QDragLeaveEvent* w = getWrapped();
        QEvent* res =

            w->clone(

            );

        // return type: QEvent*

        return RJSHelper::cpp2js_QEvent(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for clone";
    handler.trace();
    return QJSValue();

}


// member functions for static properties, forward to static function



// protected overwritten functions / events and their public invokable counterparts:

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QHelpEvent*> QHelpEvent_Wrapper::basecasters_QHelpEvent;

// static functions implementation in singleton wrapper:

// Class: QHelpEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QHelpEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                          , true

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


        if (a1.isUndefined()) {
            a1_cpp = -1;
        }
        else {
            a1_cpp = RJSHelper::js2cpp_int(handler, a1);
        }


        // call function:

        // static member function:
        // call base class static function:
        int res =

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for registerEventType";
    handler.trace();
    return QJSValue();

}

void QHelpEvent_Wrapper::init(RJSApi& handler) {

    //qmlRegisterType<QHelpEvent_Wrapper>("org.qcad", 1, 0, "QHelpEvent_Wrapper");
    qmlRegisterInterface<QHelpEvent_Wrapper>("QHelpEvent_Wrapper", 1);


    QJSEngine* engine = handler.getEngine();


    // make type scriptable for JS files:
    QJSValue global = engine->globalObject();
    RJSType_QHelpEvent* t = new RJSType_QHelpEvent();
    global.setProperty("RJSType_QHelpEvent", engine->newQObject(t));

    // initialize ID for this type:
    RJSType_QHelpEvent::getIdStatic();



    // wrapper:
    QJSValue mo = engine->newQMetaObject(&QHelpEvent_Wrapper::staticMetaObject);
    engine->globalObject().setProperty("QHelpEvent_Wrapper", mo);



    // JS base class:
    //QJSValue mob = engine->newQMetaObject(&QHelpEvent_BaseJs::staticMetaObject);
    //engine->globalObject().setProperty("QHelpEvent_BaseJs", mob);

    // singleton wrapper:
    QJSValue mos = engine->newQMetaObject(&QHelpEvent_WrapperSingleton::staticMetaObject);
    engine->globalObject().setProperty("QHelpEvent_WrapperSingleton", mos);

    // create instance of singleton wrapper for static functions:
    QHelpEvent_WrapperSingleton * s = new QHelpEvent_WrapperSingleton(handler);
    engine->globalObject().setProperty("QHelpEvent_WrapperSingletonInstance", engine->newQObject(s));
    QJSEngine::setObjectOwnership(s, QJSEngine::CppOwnership);

    QString fileName = ":generator/js/QHelpEvent.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:
QHelpEvent_Wrapper::QHelpEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QHelpEvent_Wrapper");
        setEngine(e);

        // signal forwarding:
        //initConnections();
      }

*/


// special constructor to wrap existing object:
QHelpEvent_Wrapper::QHelpEvent_Wrapper(RJSApi& h, QHelpEvent* o, bool wrappedCreated) : RJSWrapperObj(h), wrapped(o), wrappedCreated(wrappedCreated) {
    //RDebug::incCounter(QString("QHelpEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::incCounter(QString("QHelpEvent_Wrapper"));
    //setObjectName("QHelpEvent_Wrapper");
    //setHandler(h);

    // signal forwarding:
    initConnections();
}


// destructor:
QHelpEvent_Wrapper::~QHelpEvent_Wrapper() {
    //RDebug::decCounter(QString("QHelpEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::decCounter(QString("QHelpEvent_Wrapper"));

    //qDebug() << "QHelpEvent_Wrapper::~QHelpEvent_Wrapper";

    // tell script handler that this wrapper no longer exists:
    handler.unregisterWrapper(*this);


    if (wrappedCreated) {

        // delete wrapped object (copyable, JS ownership)
        //qDebug() << "deleting instance of QHelpEvent";
        delete wrapped;

    }

}

// initialization of signal forwarding

void QHelpEvent_Wrapper::initConnections() {

    //setObjectName("QHelpEvent_Wrapper");

    // tell script handler that this wrapper needs to be deleted if the engine is deleted:
    handler.registerWrapper(*this);


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

// Class: QHelpEvent
// Function:
// Source:
// Static: false
// Parameters: 3
// preceding Parameters: -1
QHelpEvent_Wrapper::QHelpEvent_Wrapper

(

    // RJSApi:
    QObject* h
    ,
    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3
)

    : RJSWrapperObj(*(RJSApi*)h)

{

    //RDebug::incCounter(QString("QHelpEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::incCounter(QString("QHelpEvent_Wrapper"));

    // check parameter types:
    if (
        RJSHelper::is_QEvent_Type(handler, a1
                                 )

        && RJSHelper::is_QPoint(handler, a2
                               )

        && RJSHelper::is_QPoint(handler, a3
                               )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: type (QEvent::Type)

        QEvent::Type a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QEvent_Type(handler, a1);

        // convert js parameter to cpp: pos (QPoint)

        QPoint a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QPoint(handler, a2);

        // convert js parameter to cpp: globalPos (QPoint)

        QPoint a3_cpp;

        a3_cpp = RJSHelper::js2cpp_QPoint(handler, a3);


        // call function:

        // construct wrapper:


        wrapped = new QHelpEvent(
            a1_cpp
            , a2_cpp
            , a3_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()
        && a2.isUndefined()
        && a3.isUndefined()

    ) {
        wrapped = nullptr;
        wrappedCreated = false;
        return;
    }


    qWarning() << "no matching constructor variant found for QHelpEvent";
    wrapped = nullptr;
    wrappedCreated = false;
    handler.trace();

}


// non-static functions:

// Class: QHelpEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::type
(

)

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:
        QHelpEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

        return RJSHelper::cpp2js_QEvent_Type(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for type";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::spontaneous
(

)

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:
        QHelpEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for spontaneous";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: setAccepted
// Source: QEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QHelpEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAccepted";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::isAccepted
(

)

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:
        QHelpEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isAccepted";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QHelpEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for accept";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QHelpEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for ignore";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::isInputEvent
(

)

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:
        QHelpEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isInputEvent";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::isPointerEvent
(

)

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:
        QHelpEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isPointerEvent";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::isSinglePointEvent
(

)

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:
        QHelpEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isSinglePointEvent";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: clone
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::clone
(

)

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:
        QHelpEvent* w = getWrapped();
        QHelpEvent* res =

            w->clone(

            );

        // return type: QHelpEvent*

        return RJSHelper::cpp2js_QHelpEvent(
                   handler,
                   // non-copyable: false
                   // return type is pointer, type is copyable:
                   // call pointer implementation of RJSHelper::cpp2js_QHelpEvent:
                   res

               );

    }

    qWarning() << "no matching function variant found for clone";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: x
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::x
(

)

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:
        QHelpEvent* w = getWrapped();
        int res =

            w->x(

            );

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for x";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: y
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::y
(

)

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:
        QHelpEvent* w = getWrapped();
        int res =

            w->y(

            );

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for y";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: globalX
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::globalX
(

)

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:
        QHelpEvent* w = getWrapped();
        int res =

            w->globalX(

            );

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for globalX";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: globalY
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::globalY
(

)

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:
        QHelpEvent* w = getWrapped();
        int res =

            w->globalY(

            );

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for globalY";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: pos
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::pos
(

)

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:
        QHelpEvent* w = getWrapped();

        // return type is reference:
        // use pointer instead 3:
        const QPoint* res =
            &
            w->pos(

            );

        // return type: const QPoint&

        return RJSHelper::cpp2js_QPoint(
                   handler,
                   // non-copyable: false
                   // return type is reference, type is copyable:
                   // convert pointer back to reference:
                   *res

               );

    }

    qWarning() << "no matching function variant found for pos";
    handler.trace();
    return QJSValue();

}

// Class: QHelpEvent
// Function: globalPos
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QHelpEvent_Wrapper::globalPos
(

)

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:
        QHelpEvent* w = getWrapped();

        // return type is reference:
        // use pointer instead 3:
        const QPoint* res =
            &
            w->globalPos(

            );

        // return type: const QPoint&

        return RJSHelper::cpp2js_QPoint(
                   handler,
                   // non-copyable: false
                   // return type is reference, type is copyable:
                   // convert pointer back to reference:
                   *res

               );

    }

    qWarning() << "no matching function variant found for globalPos";
    handler.trace();
    return QJSValue();

}


// member functions for static properties, forward to static function



// protected overwritten functions / events and their public invokable counterparts:

#include "qevent_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QActionEvent*> QActionEvent_Wrapper::basecasters_QActionEvent;

// static functions implementation in singleton wrapper:

// Class: QActionEvent
// Function: registerEventType
// Source: QEvent
// Static: true
// Parameters: 1
// preceding Parameters: -1

QJSValue
QActionEvent_WrapperSingleton::registerEventType
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                          , true

                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hint (int)

        int a1_cpp;


        if (a1.isUndefined()) {
            a1_cpp = -1;
        }
        else {
            a1_cpp = RJSHelper::js2cpp_int(handler, a1);
        }


        // call function:

        // static member function:
        // call base class static function:
        int res =

            // call static member function:
            QEvent::registerEventType(
                a1_cpp

            );

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for registerEventType";
    handler.trace();
    return QJSValue();

}

void QActionEvent_Wrapper::init(RJSApi& handler) {

    //qmlRegisterType<QActionEvent_Wrapper>("org.qcad", 1, 0, "QActionEvent_Wrapper");
    qmlRegisterInterface<QActionEvent_Wrapper>("QActionEvent_Wrapper", 1);


    QJSEngine* engine = handler.getEngine();


    // make type scriptable for JS files:
    QJSValue global = engine->globalObject();
    RJSType_QActionEvent* t = new RJSType_QActionEvent();
    global.setProperty("RJSType_QActionEvent", engine->newQObject(t));

    // initialize ID for this type:
    RJSType_QActionEvent::getIdStatic();



    // wrapper:
    QJSValue mo = engine->newQMetaObject(&QActionEvent_Wrapper::staticMetaObject);
    engine->globalObject().setProperty("QActionEvent_Wrapper", mo);



    // JS base class:
    //QJSValue mob = engine->newQMetaObject(&QActionEvent_BaseJs::staticMetaObject);
    //engine->globalObject().setProperty("QActionEvent_BaseJs", mob);

    // singleton wrapper:
    QJSValue mos = engine->newQMetaObject(&QActionEvent_WrapperSingleton::staticMetaObject);
    engine->globalObject().setProperty("QActionEvent_WrapperSingleton", mos);

    // create instance of singleton wrapper for static functions:
    QActionEvent_WrapperSingleton * s = new QActionEvent_WrapperSingleton(handler);
    engine->globalObject().setProperty("QActionEvent_WrapperSingletonInstance", engine->newQObject(s));
    QJSEngine::setObjectOwnership(s, QJSEngine::CppOwnership);

    QString fileName = ":generator/js/QActionEvent.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:
QActionEvent_Wrapper::QActionEvent_Wrapper(QJSEngine* e) : wrapped(nullptr), wrappedCreated(false) {
        //setObjectName("QActionEvent_Wrapper");
        setEngine(e);

        // signal forwarding:
        //initConnections();
      }

*/


// special constructor to wrap existing object:
QActionEvent_Wrapper::QActionEvent_Wrapper(RJSApi& h, QActionEvent* o, bool wrappedCreated) : RJSWrapperObj(h), wrapped(o), wrappedCreated(wrappedCreated) {
    //RDebug::incCounter(QString("QActionEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::incCounter(QString("QActionEvent_Wrapper"));
    //setObjectName("QActionEvent_Wrapper");
    //setHandler(h);

    // signal forwarding:
    initConnections();
}


// destructor:
QActionEvent_Wrapper::~QActionEvent_Wrapper() {
    //RDebug::decCounter(QString("QActionEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::decCounter(QString("QActionEvent_Wrapper"));

    //qDebug() << "QActionEvent_Wrapper::~QActionEvent_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 QActionEvent";

    }

}

// initialization of signal forwarding

void QActionEvent_Wrapper::initConnections() {

    //setObjectName("QActionEvent_Wrapper");

    // tell script handler that this wrapper needs to be deleted if the engine is deleted:
    handler.registerWrapper(*this);


    // wrapped object is not a QObject:
    // wrapper is managed by script engine:
    //QJSEngine::setObjectOwnership(this, QJSEngine::CppOwnership);


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

// Class: QActionEvent
// Function:
// Source:
// Static: false
// Parameters: 3
// preceding Parameters: -1
QActionEvent_Wrapper::QActionEvent_Wrapper

(

    // RJSApi:
    QObject* h
    ,
    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3
)

    : RJSWrapperObj(*(RJSApi*)h)

{

    //RDebug::incCounter(QString("QActionEvent_Wrapper_") + handler.getEngine()->objectName());
    //RDebug::incCounter(QString("QActionEvent_Wrapper"));

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_QAction_ptr(handler, a2
                                     , true

                                    )

        && RJSHelper::is_QAction_ptr(handler, a3
                                     , true

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: type (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: action (QAction)


        // pointer:
        QAction*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QAction_ptr(handler, a2);

        // convert js parameter to cpp: before (QAction)


        // pointer:
        QAction*
        a3_cpp;


        if (a3.isUndefined()) {
            a3_cpp = nullptr;
        }
        else {
            a3_cpp = RJSHelper::js2cpp_QAction_ptr(handler, a3);
        }


        // call function:

        // construct wrapper:


        wrapped = new QActionEvent(
            a1_cpp
            , a2_cpp
            , a3_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()
        && a2.isUndefined()
        && a3.isUndefined()

    ) {
        wrapped = nullptr;
        wrappedCreated = false;
        return;
    }


    qWarning() << "no matching constructor variant found for QActionEvent";
    wrapped = nullptr;
    wrappedCreated = false;
    handler.trace();

}


// non-static functions:

// Class: QActionEvent
// Function: type
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QActionEvent_Wrapper::type
(

)

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:
        QActionEvent* w = getWrapped();
        QEvent::Type res =

            w->type(

            );

        // return type: QEvent::Type

        return RJSHelper::cpp2js_QEvent_Type(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for type";
    handler.trace();
    return QJSValue();

}

// Class: QActionEvent
// Function: spontaneous
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QActionEvent_Wrapper::spontaneous
(

)

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:
        QActionEvent* w = getWrapped();
        bool res =

            w->spontaneous(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for spontaneous";
    handler.trace();
    return QJSValue();

}

// Class: QActionEvent
// Function: setAccepted
// Source: QEvent
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QActionEvent_Wrapper::setAccepted
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: accepted (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:
        QActionEvent* w = getWrapped();

        w->setAccepted(
            a1_cpp

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAccepted";
    handler.trace();
    return QJSValue();

}

// Class: QActionEvent
// Function: isAccepted
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QActionEvent_Wrapper::isAccepted
(

)

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:
        QActionEvent* w = getWrapped();
        bool res =

            w->isAccepted(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isAccepted";
    handler.trace();
    return QJSValue();

}

// Class: QActionEvent
// Function: accept
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QActionEvent_Wrapper::accept
(

)

{

    {


        // 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:
        QActionEvent* w = getWrapped();

        w->accept(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for accept";
    handler.trace();
    return QJSValue();

}

// Class: QActionEvent
// Function: ignore
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QActionEvent_Wrapper::ignore
(

)

{

    {


        // 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:
        QActionEvent* w = getWrapped();

        w->ignore(

        );

        return QJSValue();

    }

    qWarning() << "no matching function variant found for ignore";
    handler.trace();
    return QJSValue();

}

// Class: QActionEvent
// Function: isInputEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QActionEvent_Wrapper::isInputEvent
(

)

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:
        QActionEvent* w = getWrapped();
        bool res =

            w->isInputEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isInputEvent";
    handler.trace();
    return QJSValue();

}

// Class: QActionEvent
// Function: isPointerEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QActionEvent_Wrapper::isPointerEvent
(

)

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:
        QActionEvent* w = getWrapped();
        bool res =

            w->isPointerEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isPointerEvent";
    handler.trace();
    return QJSValue();

}

// Class: QActionEvent
// Function: isSinglePointEvent
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QActionEvent_Wrapper::isSinglePointEvent
(

)

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:
        QActionEvent* w = getWrapped();
        bool res =

            w->isSinglePointEvent(

            );

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isSinglePointEvent";
    handler.trace();
    return QJSValue();

}

// Class: QActionEvent
// Function: clone
// Source: QEvent
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QActionEvent_Wrapper::clone
(

)

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:
        QActionEvent* w = getWrapped();
        QEvent* res =

            w->clone(

            );

        // return type: QEvent*

        return RJSHelper::cpp2js_QEvent(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for clone";
    handler.trace();
    return QJSValue();

}

// Class: QActionEvent
// Function: action
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QActionEvent_Wrapper::action
(

)

{

    {


        // 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:
        QActionEvent* w = getWrapped();
        QAction* res =

            w->action(

            );

        // return type: QAction*

        return RJSHelper::cpp2js_QAction(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for action";
    handler.trace();
    return QJSValue();

}

// Class: QActionEvent
// Function: before
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QActionEvent_Wrapper::before
(

)

{

    {


        // 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:
        QActionEvent* w = getWrapped();
        QAction* res =

            w->before(

            );

        // return type: QAction*

        return RJSHelper::cpp2js_QAction(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for before";
    handler.trace();
    return QJSValue();

}


// member functions for static properties, forward to static function



// protected overwritten functions / events and their public invokable counterparts:

