
// Auto generated

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

#include "qlistwidget_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QListWidgetItem*> QListWidgetItem_Wrapper::basecasters_QListWidgetItem;

// static functions implementation in singleton wrapper:

#if QT_CONFIG(tooltip)

#endif

#if QT_CONFIG(whatsthis)

#endif

#ifndef QT_NO_DATASTREAM

#endif

void QListWidgetItem_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

*/


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

    // signal forwarding:
    initConnections();
}


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

    //qDebug() << "QListWidgetItem_Wrapper::~QListWidgetItem_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 QListWidgetItem";

    }

}

// initialization of signal forwarding

void QListWidgetItem_Wrapper::initConnections() {

    //setObjectName("QListWidgetItem_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: QListWidgetItem
// Function:
// Source:
// Static: false
// Parameters: 4
// preceding Parameters: -1
QListWidgetItem_Wrapper::QListWidgetItem_Wrapper

(

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

    : RJSWrapperObj(*(RJSApi*)h)

{

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

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

        && RJSHelper::is_QString(handler, a2
                                )

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

                                        )

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

                            )


    ) {

        // prepare parameters:

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

        QIcon a1_cpp;

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

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

        QString a2_cpp;

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

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


        // pointer:
        QListWidget*
        a3_cpp;


        if (a3.isUndefined()) {
            a3_cpp = nullptr;
        }
        else {
            a3_cpp = RJSHelper::js2cpp_QListWidget_ptr(handler, a3);
        }

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

        int a4_cpp;


        if (a4.isUndefined()) {
            a4_cpp = QListWidgetItem::Type;
        }
        else {
            a4_cpp = RJSHelper::js2cpp_int(handler, a4);
        }


        // call function:

        // construct wrapper:


        wrapped = new QListWidgetItem(
            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_QString(handler, a1
                             )

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

                                        )

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

                            )


    ) {

        // prepare parameters:

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

        QString a1_cpp;

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

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


        // pointer:
        QListWidget*
        a2_cpp;


        if (a2.isUndefined()) {
            a2_cpp = nullptr;
        }
        else {
            a2_cpp = RJSHelper::js2cpp_QListWidget_ptr(handler, a2);
        }

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

        int a3_cpp;


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


        // call function:

        // construct wrapper:


        wrapped = new QListWidgetItem(
            a1_cpp
            , a2_cpp
            , a3_cpp

        );
        wrappedCreated = true;


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


    }

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

                                     )

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

                            )


    ) {

        // prepare parameters:

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


        // pointer:
        QListWidget*
        a1_cpp;


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

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

        int a2_cpp;


        if (a2.isUndefined()) {
            a2_cpp = QListWidgetItem::Type;
        }
        else {
            a2_cpp = RJSHelper::js2cpp_int(handler, a2);
        }


        // call function:

        // construct wrapper:


        wrapped = new QListWidgetItem(
            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 QListWidgetItem";
    wrapped = nullptr;
    wrappedCreated = false;
    handler.trace();

}

#if QT_CONFIG(tooltip)

#endif

#if QT_CONFIG(whatsthis)

#endif

#ifndef QT_NO_DATASTREAM

#endif


// non-static functions:

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

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

            w->clone(

            );

        // return type: QListWidgetItem*

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

               );

    }

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

}

// Class: QListWidgetItem
// Function: listWidget
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::listWidget
(

)

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

            w->listWidget(

            );

        // return type: QListWidget*

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

               );

    }

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

}

// Class: QListWidgetItem
// Function: setSelected
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::setSelected
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        w->setSelected(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QListWidgetItem
// Function: isSelected
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::isSelected
(

)

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

            w->isSelected(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QListWidgetItem
// Function: setHidden
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::setHidden
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        w->setHidden(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QListWidgetItem
// Function: isHidden
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::isHidden
(

)

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

            w->isHidden(

            );

        // return type: bool

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

               );

    }

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

}

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

QJSValue
QListWidgetItem_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:
        QListWidgetItem* w = getWrapped();
        Qt::ItemFlags res =

            w->flags(

            );

        // return type: Qt::ItemFlags

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

               );

    }

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

}

// Class: QListWidgetItem
// Function: setFlags
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::setFlags
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: flags (Qt::ItemFlags)

        Qt::ItemFlags a1_cpp;

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

        w->setFlags(
            a1_cpp

        );

        return QJSValue();

    }

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

}

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

QJSValue
QListWidgetItem_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:
        QListWidgetItem* 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: QListWidgetItem
// Function: setText
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::setText
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        QString a1_cpp;

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


        // call function:

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


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

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

        w->setText(
            a1_cpp

        );

        return QJSValue();

    }

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

}

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

QJSValue
QListWidgetItem_Wrapper::icon
(

)

const

{

    {


        // call function:

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


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

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

            w->icon(

            );

        // return type: QIcon

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

               );

    }

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

}

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

QJSValue
QListWidgetItem_Wrapper::setIcon
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        QIcon a1_cpp;

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


        // call function:

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


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

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

        w->setIcon(
            a1_cpp

        );

        return QJSValue();

    }

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

}

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

QJSValue
QListWidgetItem_Wrapper::statusTip
(

)

const

{

    {


        // call function:

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


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

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

            w->statusTip(

            );

        // return type: QString

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

               );

    }

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

}

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

QJSValue
QListWidgetItem_Wrapper::setStatusTip
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        QString a1_cpp;

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


        // call function:

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


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

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

        w->setStatusTip(
            a1_cpp

        );

        return QJSValue();

    }

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

}

#if QT_CONFIG(tooltip)

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

QJSValue
QListWidgetItem_Wrapper::toolTip
(

)

const

{

    {


        // call function:

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


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

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

            w->toolTip(

            );

        // return type: QString

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

               );

    }

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

}

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

QJSValue
QListWidgetItem_Wrapper::setToolTip
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        QString a1_cpp;

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


        // call function:

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


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

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

        w->setToolTip(
            a1_cpp

        );

        return QJSValue();

    }

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

}

#endif

#if QT_CONFIG(whatsthis)

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

QJSValue
QListWidgetItem_Wrapper::whatsThis
(

)

const

{

    {


        // call function:

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


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

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

            w->whatsThis(

            );

        // return type: QString

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

               );

    }

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

}

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

QJSValue
QListWidgetItem_Wrapper::setWhatsThis
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        QString a1_cpp;

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


        // call function:

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


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

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

        w->setWhatsThis(
            a1_cpp

        );

        return QJSValue();

    }

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

}

#endif

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

QJSValue
QListWidgetItem_Wrapper::font
(

)

const

{

    {


        // call function:

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


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

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

            w->font(

            );

        // return type: QFont

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

               );

    }

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

}

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

QJSValue
QListWidgetItem_Wrapper::setFont
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        QFont a1_cpp;

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


        // call function:

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


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

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

        w->setFont(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QListWidgetItem
// Function: textAlignment
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::textAlignment
(

)

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

            w->textAlignment(

            );

        // return type: int

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

               );

    }

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

}

// Class: QListWidgetItem
// Function: setTextAlignment
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::setTextAlignment
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        w->setTextAlignment(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QListWidgetItem
// Function: background
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::background
(

)

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

            w->background(

            );

        // return type: QBrush

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

               );

    }

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

}

// Class: QListWidgetItem
// Function: setBackground
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::setBackground
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: brush (QBrush)

        QBrush a1_cpp;

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

        w->setBackground(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QListWidgetItem
// Function: foreground
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::foreground
(

)

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

            w->foreground(

            );

        // return type: QBrush

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

               );

    }

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

}

// Class: QListWidgetItem
// Function: setForeground
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::setForeground
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: brush (QBrush)

        QBrush a1_cpp;

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

        w->setForeground(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QListWidgetItem
// Function: checkState
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::checkState
(

)

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

            w->checkState(

            );

        // return type: Qt::CheckState

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

               );

    }

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

}

// Class: QListWidgetItem
// Function: setCheckState
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::setCheckState
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: state (Qt::CheckState)

        Qt::CheckState a1_cpp;

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

        w->setCheckState(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QListWidgetItem
// Function: sizeHint
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::sizeHint
(

)

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

            w->sizeHint(

            );

        // return type: QSize

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

               );

    }

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

}

// Class: QListWidgetItem
// Function: setSizeHint
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::setSizeHint
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: size (QSize)

        QSize a1_cpp;

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

        w->setSizeHint(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QListWidgetItem
// Function: data
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::data
(

    const QJSValue&
    a1
)

const

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: role (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:
        QListWidgetItem* w = getWrapped();
        QVariant res =

            w->data(
                a1_cpp

            );

        // return type: QVariant

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

               );

    }

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

}

// Class: QListWidgetItem
// Function: setData
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidgetItem_Wrapper::setData
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

        && RJSHelper::is_QVariant(handler, a2
                                 )


    ) {

        // prepare parameters:

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

        int a1_cpp;

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

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

        QVariant a2_cpp;

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


        // call function:

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


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

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

        w->setData(
            a1_cpp
            , a2_cpp

        );

        return QJSValue();

    }

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

}

#ifndef QT_NO_DATASTREAM

#endif

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

QJSValue
QListWidgetItem_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:
        QListWidgetItem* w = getWrapped();
        int res =

            w->type(

            );

        // return type: int

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

               );

    }

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

}


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



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

#include "qlistwidget_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QListWidget*> QListWidget_Wrapper::basecasters_QListWidget;

// static functions implementation in singleton wrapper:

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

QJSValue
QListWidget_WrapperSingleton::tr
(

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

{

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

                              )

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

                                 )

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

                            )


    ) {

        // prepare parameters:

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


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

        // convert js parameter to cpp:  (char)


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

        // convert js parameter to cpp:  (int)

        int a3_cpp;


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


        // call function:

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

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

            );

        // return type: QString

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

               );

    }

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

}

// Class: QListWidget
// Function: setTabOrder
// Source: QWidget
// Static: true
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_WrapperSingleton::setTabOrder
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

                                 )

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

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

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

        // convert js parameter to cpp:  (QWidget)


        // pointer:
        QWidget*
        a2_cpp;

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


        // call function:

        // static member function:
        // call base class static function:

        // call static member function:
        QWidget::setTabOrder(
            a1_cpp
            , a2_cpp

        );

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: mouseGrabber
// Source: QWidget
// Static: true
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_WrapperSingleton::mouseGrabber
(

)

{

    {


        // call function:

        // static member function:
        // call base class static function:
        QWidget* res =

            // call static member function:
            QWidget::mouseGrabber(

            );

        // return type: QWidget*

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

               );

    }

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

}

// Class: QListWidget
// Function: keyboardGrabber
// Source: QWidget
// Static: true
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_WrapperSingleton::keyboardGrabber
(

)

{

    {


        // call function:

        // static member function:
        // call base class static function:
        QWidget* res =

            // call static member function:
            QWidget::keyboardGrabber(

            );

        // return type: QWidget*

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

               );

    }

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

}

#if QT_CONFIG(draganddrop)

#endif

#if QT_CONFIG(draganddrop)

#endif

void QListWidget_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

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

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

*/


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

    // signal forwarding:
    initConnections();
}


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

    //qDebug() << "QListWidget_Wrapper::~QListWidget_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 QListWidget";

    }

}

// initialization of signal forwarding

void QListWidget_Wrapper::initConnections() {

    //setObjectName("QListWidget_Wrapper");

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


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


    if (hasWrapped()) {

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

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

        // set up signal forwarding:

        connect(
            getWrapped(),
            SIGNAL(customContextMenuRequested(const QPoint&)),
            this,
            SLOT(customContextMenuRequestedEmitter(const QPoint&))
        );

        connect(
            getWrapped(),
            SIGNAL(doubleClicked(const QModelIndex&)),
            this,
            SLOT(doubleClickedEmitter(const QModelIndex&))
        );

        connect(
            getWrapped(),
            SIGNAL(itemPressed(QListWidgetItem*)),
            this,
            SLOT(itemPressedEmitter(QListWidgetItem*))
        );

        connect(
            getWrapped(),
            SIGNAL(itemClicked(QListWidgetItem*)),
            this,
            SLOT(itemClickedEmitter(QListWidgetItem*))
        );

        connect(
            getWrapped(),
            SIGNAL(itemDoubleClicked(QListWidgetItem*)),
            this,
            SLOT(itemDoubleClickedEmitter(QListWidgetItem*))
        );

        connect(
            getWrapped(),
            SIGNAL(itemActivated(QListWidgetItem*)),
            this,
            SLOT(itemActivatedEmitter(QListWidgetItem*))
        );

        connect(
            getWrapped(),
            SIGNAL(itemEntered(QListWidgetItem*)),
            this,
            SLOT(itemEnteredEmitter(QListWidgetItem*))
        );

        connect(
            getWrapped(),
            SIGNAL(itemChanged(QListWidgetItem*)),
            this,
            SLOT(itemChangedEmitter(QListWidgetItem*))
        );

        connect(
            getWrapped(),
            SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)),
            this,
            SLOT(currentItemChangedEmitter(QListWidgetItem*, QListWidgetItem*))
        );

        connect(
            getWrapped(),
            SIGNAL(currentTextChanged(const QString&)),
            this,
            SLOT(currentTextChangedEmitter(const QString&))
        );

        connect(
            getWrapped(),
            SIGNAL(currentRowChanged(int)),
            this,
            SLOT(currentRowChangedEmitter(int))
        );

        connect(
            getWrapped(),
            SIGNAL(itemSelectionChanged()),
            this,
            SLOT(itemSelectionChangedEmitter())
        );

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

    }
}


// constructors:

#if QT_CONFIG(draganddrop)

#endif

#if QT_CONFIG(draganddrop)

#endif


// non-static functions:

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

QJSValue
QListWidget_Wrapper::objectName
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->objectName(

            );

        //setRecFlag(false);

        // return type: QString

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

               );

    }

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

}

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

QJSValue
QListWidget_Wrapper::setObjectName
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        QString a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setObjectName(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QListWidget_Wrapper::isWidgetType
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->isWidgetType(

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

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

QJSValue
QListWidget_Wrapper::isWindowType
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->isWindowType(

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

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

QJSValue
QListWidget_Wrapper::signalsBlocked
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->signalsBlocked(

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

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

QJSValue
QListWidget_Wrapper::blockSignals
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        bool a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

            w->blockSignals(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

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

QJSValue
QListWidget_Wrapper::findChild
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

const

{

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

                             )

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

                                            )


    ) {

        // prepare parameters:

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

        QString a1_cpp;


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

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

        Qt::FindChildOptions a2_cpp;


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


        // call function:

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


        //setRecFlag(true);

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

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

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

            );

        //setRecFlag(false);

        // return type: QObject*

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

               );

    }

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

}

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

QJSValue
QListWidget_Wrapper::children
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

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

            );

        //setRecFlag(false);

        // return type: const QObjectList&

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

               );

    }

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

}

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

QJSValue
QListWidget_Wrapper::installEventFilter
(

    const QJSValue&
    a1
)

{

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

                                 )


    ) {

        // prepare parameters:

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


        // pointer:
        QObject*
        a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->installEventFilter(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QListWidget_Wrapper::removeEventFilter
(

    const QJSValue&
    a1
)

{

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

                                 )


    ) {

        // prepare parameters:

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


        // pointer:
        QObject*
        a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->removeEventFilter(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QListWidget_Wrapper::dumpObjectTree
(

)

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

        w->dumpObjectTree(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    {


        // call function:

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


        //setRecFlag(true);

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

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

        w->dumpObjectTree(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QListWidget_Wrapper::dumpObjectInfo
(

)

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

        w->dumpObjectInfo(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    {


        // call function:

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


        //setRecFlag(true);

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

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

        w->dumpObjectInfo(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QListWidget_Wrapper::setProperty
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

                              )

        && RJSHelper::is_QVariant(handler, a2
                                 )


    ) {

        // prepare parameters:

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


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

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

        QVariant a2_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

            w->setProperty(
                a1_cpp
                , a2_cpp

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

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

QJSValue
QListWidget_Wrapper::property
(

    const QJSValue&
    a1
)

const

{

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

                              )


    ) {

        // prepare parameters:

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


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


        // call function:

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


        //setRecFlag(true);

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

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

            w->property(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QVariant

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

               );

    }

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

}

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

QJSValue
QListWidget_Wrapper::dynamicPropertyNames
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->dynamicPropertyNames(

            );

        //setRecFlag(false);

        // return type: QList<QByteArray>

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

               );

    }

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

}

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

QJSValue
QListWidget_Wrapper::parent
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->parent(

            );

        //setRecFlag(false);

        // return type: QObject*

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

               );

    }

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

}

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

QJSValue
QListWidget_Wrapper::deleteLater
(

)

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

        w->deleteLater(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: devType
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::devType
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->devType(

            );

        //setRecFlag(false);

        // return type: int

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

               );

    }

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

}

// Class: QListWidget
// Function: createWinId
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::createWinId
(

)

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

        w->createWinId(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: isWindow
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isWindow
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->isWindow(

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

// Class: QListWidget
// Function: isModal
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isModal
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->isModal(

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

// Class: QListWidget
// Function: windowModality
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::windowModality
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->windowModality(

            );

        //setRecFlag(false);

        // return type: Qt::WindowModality

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

               );

    }

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

}

// Class: QListWidget
// Function: setWindowModality
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWindowModality
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: windowModality (Qt::WindowModality)

        Qt::WindowModality a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setWindowModality(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: isEnabled
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isEnabled
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->isEnabled(

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

// Class: QListWidget
// Function: isEnabledTo
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isEnabledTo
(

    const QJSValue&
    a1
)

const

{

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

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

            w->isEnabledTo(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

// Class: QListWidget
// Function: setEnabled
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setEnabled
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (bool)

        bool a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setEnabled(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: setDisabled
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setDisabled
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (bool)

        bool a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setDisabled(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: setWindowModified
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWindowModified
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (bool)

        bool a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setWindowModified(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: frameGeometry
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::frameGeometry
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->frameGeometry(

            );

        //setRecFlag(false);

        // return type: QRect

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

               );

    }

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

}

// Class: QListWidget
// Function: geometry
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::geometry
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

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

            );

        //setRecFlag(false);

        // 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 geometry";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: normalGeometry
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::normalGeometry
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->normalGeometry(

            );

        //setRecFlag(false);

        // return type: QRect

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

               );

    }

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

}

// Class: QListWidget
// Function: x
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::x
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->x(

            );

        //setRecFlag(false);

        // 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: QListWidget
// Function: y
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::y
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->y(

            );

        //setRecFlag(false);

        // 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: QListWidget
// Function: pos
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::pos
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->pos(

            );

        //setRecFlag(false);

        // return type: QPoint

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

               );

    }

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

}

// Class: QListWidget
// Function: frameSize
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::frameSize
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->frameSize(

            );

        //setRecFlag(false);

        // return type: QSize

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

               );

    }

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

}

// Class: QListWidget
// Function: size
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::size
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->size(

            );

        //setRecFlag(false);

        // return type: QSize

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

               );

    }

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

}

// Class: QListWidget
// Function: width
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::width
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->width(

            );

        //setRecFlag(false);

        // return type: int

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

               );

    }

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

}

// Class: QListWidget
// Function: height
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::height
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->height(

            );

        //setRecFlag(false);

        // return type: int

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

               );

    }

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

}

// Class: QListWidget
// Function: rect
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::rect
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->rect(

            );

        //setRecFlag(false);

        // return type: QRect

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

               );

    }

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

}

// Class: QListWidget
// Function: childrenRect
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::childrenRect
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->childrenRect(

            );

        //setRecFlag(false);

        // return type: QRect

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

               );

    }

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

}

// Class: QListWidget
// Function: childrenRegion
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::childrenRegion
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->childrenRegion(

            );

        //setRecFlag(false);

        // return type: QRegion

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

               );

    }

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

}

// Class: QListWidget
// Function: minimumSize
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::minimumSize
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->minimumSize(

            );

        //setRecFlag(false);

        // return type: QSize

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

               );

    }

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

}

// Class: QListWidget
// Function: maximumSize
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::maximumSize
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->maximumSize(

            );

        //setRecFlag(false);

        // return type: QSize

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

               );

    }

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

}

// Class: QListWidget
// Function: minimumWidth
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::minimumWidth
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->minimumWidth(

            );

        //setRecFlag(false);

        // return type: int

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

               );

    }

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

}

// Class: QListWidget
// Function: minimumHeight
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::minimumHeight
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->minimumHeight(

            );

        //setRecFlag(false);

        // return type: int

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

               );

    }

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

}

// Class: QListWidget
// Function: maximumWidth
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::maximumWidth
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->maximumWidth(

            );

        //setRecFlag(false);

        // return type: int

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

               );

    }

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

}

// Class: QListWidget
// Function: maximumHeight
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::maximumHeight
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->maximumHeight(

            );

        //setRecFlag(false);

        // return type: int

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

               );

    }

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

}

// Class: QListWidget
// Function: setMinimumSize
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setMinimumSize
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

        && RJSHelper::is_int(handler, a2
                            )


    ) {

        // prepare parameters:

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

        int a1_cpp;

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

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

        int a2_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setMinimumSize(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QSize)

        QSize a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setMinimumSize(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: setMaximumSize
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setMaximumSize
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

        && RJSHelper::is_int(handler, a2
                            )


    ) {

        // prepare parameters:

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

        int a1_cpp;

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

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

        int a2_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setMaximumSize(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QSize)

        QSize a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setMaximumSize(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: setMinimumWidth
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setMinimumWidth
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        int a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setMinimumWidth(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: setMinimumHeight
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setMinimumHeight
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        int a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setMinimumHeight(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: setMaximumWidth
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setMaximumWidth
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        int a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setMaximumWidth(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: setMaximumHeight
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setMaximumHeight
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        int a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setMaximumHeight(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: sizeIncrement
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::sizeIncrement
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->sizeIncrement(

            );

        //setRecFlag(false);

        // return type: QSize

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

               );

    }

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

}

// Class: QListWidget
// Function: setSizeIncrement
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setSizeIncrement
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

        && RJSHelper::is_int(handler, a2
                            )


    ) {

        // prepare parameters:

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

        int a1_cpp;

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

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

        int a2_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setSizeIncrement(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QSize)

        QSize a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setSizeIncrement(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: baseSize
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::baseSize
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->baseSize(

            );

        //setRecFlag(false);

        // return type: QSize

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

               );

    }

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

}

// Class: QListWidget
// Function: setBaseSize
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setBaseSize
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

        && RJSHelper::is_int(handler, a2
                            )


    ) {

        // prepare parameters:

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

        int a1_cpp;

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

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

        int a2_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setBaseSize(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QSize)

        QSize a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setBaseSize(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: setFixedSize
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setFixedSize
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

        && RJSHelper::is_int(handler, a2
                            )


    ) {

        // prepare parameters:

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

        int a1_cpp;

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

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

        int a2_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setFixedSize(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QSize)

        QSize a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setFixedSize(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: setFixedWidth
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setFixedWidth
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        int a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setFixedWidth(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: setFixedHeight
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setFixedHeight
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        int a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setFixedHeight(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: mapToGlobal
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::mapToGlobal
(

    const QJSValue&
    a1
)

const

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QPoint)

        QPoint a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

            w->mapToGlobal(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QPoint

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

               );

    }

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QPointF)

        QPointF a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

            w->mapToGlobal(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QPointF

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

               );

    }

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

}

// Class: QListWidget
// Function: mapFromGlobal
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::mapFromGlobal
(

    const QJSValue&
    a1
)

const

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QPoint)

        QPoint a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

            w->mapFromGlobal(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QPoint

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

               );

    }

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QPointF)

        QPointF a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

            w->mapFromGlobal(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QPointF

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

               );

    }

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

}

// Class: QListWidget
// Function: mapToParent
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::mapToParent
(

    const QJSValue&
    a1
)

const

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QPoint)

        QPoint a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

            w->mapToParent(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QPoint

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

               );

    }

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

}

// Class: QListWidget
// Function: mapFromParent
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::mapFromParent
(

    const QJSValue&
    a1
)

const

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QPoint)

        QPoint a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

            w->mapFromParent(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QPoint

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

               );

    }

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

}

// Class: QListWidget
// Function: mapTo
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::mapTo
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

const

{

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

                                 )

        && RJSHelper::is_QPoint(handler, a2
                               )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

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

        // convert js parameter to cpp:  (QPoint)

        QPoint a2_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

            w->mapTo(
                a1_cpp
                , a2_cpp

            );

        //setRecFlag(false);

        // return type: QPoint

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

               );

    }

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

}

// Class: QListWidget
// Function: mapFrom
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::mapFrom
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

const

{

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

                                 )

        && RJSHelper::is_QPoint(handler, a2
                               )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

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

        // convert js parameter to cpp:  (QPoint)

        QPoint a2_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

            w->mapFrom(
                a1_cpp
                , a2_cpp

            );

        //setRecFlag(false);

        // return type: QPoint

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

               );

    }

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

                                 )

        && RJSHelper::is_QPointF(handler, a2
                                )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

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

        // convert js parameter to cpp:  (QPointF)

        QPointF a2_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

            w->mapFrom(
                a1_cpp
                , a2_cpp

            );

        //setRecFlag(false);

        // return type: QPointF

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

               );

    }

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

}

// Class: QListWidget
// Function: window
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::window
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->window(

            );

        //setRecFlag(false);

        // return type: QWidget*

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

               );

    }

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

}

// Class: QListWidget
// Function: nativeParentWidget
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::nativeParentWidget
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->nativeParentWidget(

            );

        //setRecFlag(false);

        // return type: QWidget*

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

               );

    }

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

}

// Class: QListWidget
// Function: topLevelWidget
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::topLevelWidget
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->topLevelWidget(

            );

        //setRecFlag(false);

        // return type: QWidget*

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

               );

    }

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

}

// Class: QListWidget
// Function: palette
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::palette
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

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

            );

        //setRecFlag(false);

        // return type: const QPalette&

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

               );

    }

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

}

// Class: QListWidget
// Function: setPalette
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setPalette
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QPalette)

        QPalette a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setPalette(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: setBackgroundRole
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setBackgroundRole
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QPalette::ColorRole)

        QPalette::ColorRole a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setBackgroundRole(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: backgroundRole
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::backgroundRole
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QPalette::ColorRole res =

            w->backgroundRole(

            );

        //setRecFlag(false);

        // return type: QPalette::ColorRole

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

               );

    }

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

}

// Class: QListWidget
// Function: setForegroundRole
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setForegroundRole
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QPalette::ColorRole)

        QPalette::ColorRole a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setForegroundRole(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: foregroundRole
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::foregroundRole
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QPalette::ColorRole res =

            w->foregroundRole(

            );

        //setRecFlag(false);

        // return type: QPalette::ColorRole

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

               );

    }

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

}

// Class: QListWidget
// Function: font
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::font
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

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

            );

        //setRecFlag(false);

        // return type: const QFont&

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

               );

    }

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

}

// Class: QListWidget
// Function: setFont
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setFont
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QFont)

        QFont a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setFont(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: fontInfo
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::fontInfo
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->fontInfo(

            );

        //setRecFlag(false);

        // return type: QFontInfo

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

               );

    }

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

}

// Class: QListWidget
// Function: cursor
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::cursor
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->cursor(

            );

        //setRecFlag(false);

        // return type: QCursor

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

               );

    }

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

}

// Class: QListWidget
// Function: setCursor
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setCursor
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QCursor)

        QCursor a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setCursor(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: unsetCursor
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::unsetCursor
(

)

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

        w->unsetCursor(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: setMouseTracking
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setMouseTracking
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        bool a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setMouseTracking(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: hasMouseTracking
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::hasMouseTracking
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->hasMouseTracking(

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

// Class: QListWidget
// Function: underMouse
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::underMouse
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->underMouse(

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

// Class: QListWidget
// Function: setTabletTracking
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setTabletTracking
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        bool a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setTabletTracking(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QListWidget
// Function: hasTabletTracking
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::hasTabletTracking
(

)

const

{

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->hasTabletTracking(

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

// Class: QListWidget
// Function: setMask
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setMask
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QBitmap)

        QBitmap a1_cpp;

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


        // call function:

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


        //setRecFlag(true);

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

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

        w->setMask(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QRegion(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QRegion)

        QRegion a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QRegion(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setMask(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setMask";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: mask
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::mask
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QRegion res =

            w->mask(

            );

        //setRecFlag(false);

        // return type: QRegion

        return RJSHelper::cpp2js_QRegion(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for mask";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: clearMask
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::clearMask
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->clearMask(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for clearMask";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: grab
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::grab
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QRect(handler, a1
                            , true

                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: rectangle (QRect)

        QRect a1_cpp;


        if (a1.isUndefined()) {
            a1_cpp = QRect(QPoint(0, 0), QSize(-1, -1));
        }
        else {
            a1_cpp = RJSHelper::js2cpp_QRect(handler, a1);
        }


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QPixmap res =

            w->grab(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QPixmap

        return RJSHelper::cpp2js_QPixmap(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for grab";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: grabGesture
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::grabGesture
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_GestureType(handler, a1
                                    )

        && RJSHelper::is_Qt_GestureFlags(handler, a2
                                         , true

                                        )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: type (Qt::GestureType)

        Qt::GestureType a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_GestureType(handler, a1);

        // convert js parameter to cpp: flags (Qt::GestureFlags)

        Qt::GestureFlags a2_cpp;


        if (a2.isUndefined()) {
            a2_cpp = Qt::GestureFlags();
        }
        else {
            a2_cpp = RJSHelper::js2cpp_Qt_GestureFlags(handler, a2);
        }


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->grabGesture(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for grabGesture";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: ungrabGesture
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::ungrabGesture
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_GestureType(handler, a1
                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: type (Qt::GestureType)

        Qt::GestureType a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_GestureType(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->ungrabGesture(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for ungrabGesture";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setWindowTitle
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWindowTitle
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setWindowTitle(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setWindowTitle";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setStyleSheet
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setStyleSheet
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: styleSheet (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setStyleSheet(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setStyleSheet";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: styleSheet
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::styleSheet
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QString res =

            w->styleSheet(

            );

        //setRecFlag(false);

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for styleSheet";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: windowTitle
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::windowTitle
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QString res =

            w->windowTitle(

            );

        //setRecFlag(false);

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for windowTitle";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setWindowIcon
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWindowIcon
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QIcon(handler, a1
                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: icon (QIcon)

        QIcon a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QIcon(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setWindowIcon(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setWindowIcon";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: windowIcon
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::windowIcon
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QIcon res =

            w->windowIcon(

            );

        //setRecFlag(false);

        // return type: QIcon

        return RJSHelper::cpp2js_QIcon(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for windowIcon";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setWindowIconText
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWindowIconText
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setWindowIconText(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setWindowIconText";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: windowIconText
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::windowIconText
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QString res =

            w->windowIconText(

            );

        //setRecFlag(false);

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for windowIconText";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setWindowRole
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWindowRole
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setWindowRole(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setWindowRole";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: windowRole
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::windowRole
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QString res =

            w->windowRole(

            );

        //setRecFlag(false);

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for windowRole";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setWindowFilePath
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWindowFilePath
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: filePath (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setWindowFilePath(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setWindowFilePath";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: windowFilePath
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::windowFilePath
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QString res =

            w->windowFilePath(

            );

        //setRecFlag(false);

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for windowFilePath";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setWindowOpacity
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWindowOpacity
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_qreal(handler, a1
                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: level (qreal)

        qreal a1_cpp;

        a1_cpp = RJSHelper::js2cpp_qreal(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setWindowOpacity(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setWindowOpacity";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: windowOpacity
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::windowOpacity
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        qreal res =

            w->windowOpacity(

            );

        //setRecFlag(false);

        // return type: qreal

        return RJSHelper::cpp2js_qreal(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for windowOpacity";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isWindowModified
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isWindowModified
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isWindowModified(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isWindowModified";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setToolTip
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setToolTip
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setToolTip(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setToolTip";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: toolTip
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::toolTip
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QString res =

            w->toolTip(

            );

        //setRecFlag(false);

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for toolTip";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setToolTipDuration
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setToolTipDuration
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: msec (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setToolTipDuration(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setToolTipDuration";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: toolTipDuration
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::toolTipDuration
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->toolTipDuration(

            );

        //setRecFlag(false);

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for toolTipDuration";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setStatusTip
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setStatusTip
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setStatusTip(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setStatusTip";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: statusTip
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::statusTip
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QString res =

            w->statusTip(

            );

        //setRecFlag(false);

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for statusTip";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setWhatsThis
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWhatsThis
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setWhatsThis(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setWhatsThis";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: whatsThis
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::whatsThis
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QString res =

            w->whatsThis(

            );

        //setRecFlag(false);

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for whatsThis";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: accessibleName
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::accessibleName
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QString res =

            w->accessibleName(

            );

        //setRecFlag(false);

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for accessibleName";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setAccessibleName
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setAccessibleName
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: name (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setAccessibleName(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAccessibleName";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: accessibleDescription
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::accessibleDescription
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QString res =

            w->accessibleDescription(

            );

        //setRecFlag(false);

        // return type: QString

        return RJSHelper::cpp2js_QString(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for accessibleDescription";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setAccessibleDescription
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setAccessibleDescription
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: description (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setAccessibleDescription(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAccessibleDescription";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setLayoutDirection
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setLayoutDirection
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_LayoutDirection(handler, a1
                                        )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: direction (Qt::LayoutDirection)

        Qt::LayoutDirection a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_LayoutDirection(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setLayoutDirection(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setLayoutDirection";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: layoutDirection
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::layoutDirection
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        Qt::LayoutDirection res =

            w->layoutDirection(

            );

        //setRecFlag(false);

        // return type: Qt::LayoutDirection

        return RJSHelper::cpp2js_Qt_LayoutDirection(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for layoutDirection";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: unsetLayoutDirection
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::unsetLayoutDirection
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->unsetLayoutDirection(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for unsetLayoutDirection";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setLocale
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setLocale
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QLocale(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: locale (QLocale)

        QLocale a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QLocale(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setLocale(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setLocale";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: locale
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::locale
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QLocale res =

            w->locale(

            );

        //setRecFlag(false);

        // return type: QLocale

        return RJSHelper::cpp2js_QLocale(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for locale";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: unsetLocale
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::unsetLocale
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->unsetLocale(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for unsetLocale";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isRightToLeft
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isRightToLeft
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isRightToLeft(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isRightToLeft";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isLeftToRight
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isLeftToRight
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isLeftToRight(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isLeftToRight";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isActiveWindow
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isActiveWindow
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isActiveWindow(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isActiveWindow";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: activateWindow
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::activateWindow
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->activateWindow(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for activateWindow";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: clearFocus
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::clearFocus
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->clearFocus(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for clearFocus";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setFocus
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setFocus
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_FocusReason(handler, a1
                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: reason (Qt::FocusReason)

        Qt::FocusReason a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_FocusReason(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setFocus(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setFocus(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setFocus";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: focusPolicy
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::focusPolicy
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        Qt::FocusPolicy res =

            w->focusPolicy(

            );

        //setRecFlag(false);

        // return type: Qt::FocusPolicy

        return RJSHelper::cpp2js_Qt_FocusPolicy(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for focusPolicy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setFocusPolicy
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setFocusPolicy
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_FocusPolicy(handler, a1
                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: policy (Qt::FocusPolicy)

        Qt::FocusPolicy a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_FocusPolicy(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setFocusPolicy(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setFocusPolicy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: hasFocus
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::hasFocus
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->hasFocus(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for hasFocus";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setFocusProxy
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setFocusProxy
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setFocusProxy(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setFocusProxy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: focusProxy
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::focusProxy
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QWidget* res =

            w->focusProxy(

            );

        //setRecFlag(false);

        // return type: QWidget*

        return RJSHelper::cpp2js_QWidget(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for focusProxy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: contextMenuPolicy
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::contextMenuPolicy
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        Qt::ContextMenuPolicy res =

            w->contextMenuPolicy(

            );

        //setRecFlag(false);

        // return type: Qt::ContextMenuPolicy

        return RJSHelper::cpp2js_Qt_ContextMenuPolicy(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for contextMenuPolicy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setContextMenuPolicy
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setContextMenuPolicy
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_ContextMenuPolicy(handler, a1
                                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: policy (Qt::ContextMenuPolicy)

        Qt::ContextMenuPolicy a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_ContextMenuPolicy(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setContextMenuPolicy(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setContextMenuPolicy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: grabMouse
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::grabMouse
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QCursor(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QCursor)

        QCursor a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QCursor(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->grabMouse(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->grabMouse(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for grabMouse";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: releaseMouse
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::releaseMouse
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->releaseMouse(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for releaseMouse";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: grabKeyboard
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::grabKeyboard
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->grabKeyboard(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for grabKeyboard";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: releaseKeyboard
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::releaseKeyboard
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->releaseKeyboard(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for releaseKeyboard";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: grabShortcut
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::grabShortcut
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_QKeySequence(handler, a1
                                  )

        && RJSHelper::is_Qt_ShortcutContext(handler, a2
                                            , true

                                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: key (QKeySequence)

        QKeySequence a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QKeySequence(handler, a1);

        // convert js parameter to cpp: context (Qt::ShortcutContext)

        Qt::ShortcutContext a2_cpp;


        if (a2.isUndefined()) {
            a2_cpp = Qt::WindowShortcut;
        }
        else {
            a2_cpp = RJSHelper::js2cpp_Qt_ShortcutContext(handler, a2);
        }


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->grabShortcut(
                a1_cpp
                , a2_cpp

            );

        //setRecFlag(false);

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for grabShortcut";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: releaseShortcut
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::releaseShortcut
(

    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();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->releaseShortcut(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for releaseShortcut";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setShortcutEnabled
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setShortcutEnabled
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_bool(handler, a2
                              , true

                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: id (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: enable (bool)

        bool a2_cpp;


        if (a2.isUndefined()) {
            a2_cpp = true;
        }
        else {
            a2_cpp = RJSHelper::js2cpp_bool(handler, a2);
        }


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setShortcutEnabled(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setShortcutEnabled";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setShortcutAutoRepeat
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setShortcutAutoRepeat
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_bool(handler, a2
                              , true

                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: id (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: enable (bool)

        bool a2_cpp;


        if (a2.isUndefined()) {
            a2_cpp = true;
        }
        else {
            a2_cpp = RJSHelper::js2cpp_bool(handler, a2);
        }


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setShortcutAutoRepeat(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setShortcutAutoRepeat";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: updatesEnabled
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::updatesEnabled
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->updatesEnabled(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for updatesEnabled";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setUpdatesEnabled
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setUpdatesEnabled
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: enable (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setUpdatesEnabled(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setUpdatesEnabled";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: repaint
// Source: QWidget
// Static: false
// Parameters: 4
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::repaint
(

    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3,
    const QJSValue&
    a4
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_int(handler, a2
                            )

        && RJSHelper::is_int(handler, a3
                            )

        && RJSHelper::is_int(handler, a4
                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: x (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: y (int)

        int a2_cpp;

        a2_cpp = RJSHelper::js2cpp_int(handler, a2);

        // convert js parameter to cpp: w (int)

        int a3_cpp;

        a3_cpp = RJSHelper::js2cpp_int(handler, a3);

        // convert js parameter to cpp: h (int)

        int a4_cpp;

        a4_cpp = RJSHelper::js2cpp_int(handler, a4);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->repaint(
            a1_cpp
            , a2_cpp
            , a3_cpp
            , a4_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QRect(handler, a1
                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QRect)

        QRect a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QRect(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->repaint(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QRegion(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QRegion)

        QRegion a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QRegion(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->repaint(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for repaint";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setVisible
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setVisible
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: visible (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setVisible(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setVisible";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setHidden
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setHidden
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hidden (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setHidden(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setHidden";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: show
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::show
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->show(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for show";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: hide
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::hide
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->hide(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for hide";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: showMinimized
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::showMinimized
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->showMinimized(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for showMinimized";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: showMaximized
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::showMaximized
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->showMaximized(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for showMaximized";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: showFullScreen
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::showFullScreen
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->showFullScreen(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for showFullScreen";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: showNormal
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::showNormal
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->showNormal(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for showNormal";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: close
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::close
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->close(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for close";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: raise
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::raise
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->raise(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for raise";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: lower
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::lower
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->lower(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for lower";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: stackUnder
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::stackUnder
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->stackUnder(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for stackUnder";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: move
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::move
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_int(handler, a2
                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: x (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: y (int)

        int a2_cpp;

        a2_cpp = RJSHelper::js2cpp_int(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->move(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QPoint(handler, a1
                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QPoint)

        QPoint a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QPoint(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->move(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for move";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: resize
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::resize
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_int(handler, a2
                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: w (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: h (int)

        int a2_cpp;

        a2_cpp = RJSHelper::js2cpp_int(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->resize(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QSize(handler, a1
                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QSize)

        QSize a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QSize(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->resize(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for resize";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setGeometry
// Source: QWidget
// Static: false
// Parameters: 4
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setGeometry
(

    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3,
    const QJSValue&
    a4
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_int(handler, a2
                            )

        && RJSHelper::is_int(handler, a3
                            )

        && RJSHelper::is_int(handler, a4
                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: x (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: y (int)

        int a2_cpp;

        a2_cpp = RJSHelper::js2cpp_int(handler, a2);

        // convert js parameter to cpp: w (int)

        int a3_cpp;

        a3_cpp = RJSHelper::js2cpp_int(handler, a3);

        // convert js parameter to cpp: h (int)

        int a4_cpp;

        a4_cpp = RJSHelper::js2cpp_int(handler, a4);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setGeometry(
            a1_cpp
            , a2_cpp
            , a3_cpp
            , a4_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QRect(handler, a1
                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QRect)

        QRect a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QRect(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setGeometry(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setGeometry";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: saveGeometry
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::saveGeometry
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QByteArray res =

            w->saveGeometry(

            );

        //setRecFlag(false);

        // return type: QByteArray

        return RJSHelper::cpp2js_QByteArray(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for saveGeometry";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: restoreGeometry
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::restoreGeometry
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QByteArray(handler, a1
                                )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: geometry (QByteArray)

        QByteArray a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QByteArray(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->restoreGeometry(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for restoreGeometry";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: adjustSize
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::adjustSize
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->adjustSize(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for adjustSize";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isVisible
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isVisible
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isVisible(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isVisible";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isVisibleTo
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isVisibleTo
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isVisibleTo(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isVisibleTo";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isHidden
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isHidden
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isHidden(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isHidden";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isMinimized
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isMinimized
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isMinimized(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isMinimized";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isMaximized
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isMaximized
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isMaximized(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isMaximized";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isFullScreen
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isFullScreen
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isFullScreen(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isFullScreen";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: windowState
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::windowState
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        Qt::WindowStates res =

            w->windowState(

            );

        //setRecFlag(false);

        // return type: Qt::WindowStates

        return RJSHelper::cpp2js_Qt_WindowStates(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for windowState";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setWindowState
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWindowState
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_WindowStates(handler, a1
                                     )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: state (Qt::WindowStates)

        Qt::WindowStates a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_WindowStates(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setWindowState(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setWindowState";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: overrideWindowState
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::overrideWindowState
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_WindowStates(handler, a1
                                     )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: state (Qt::WindowStates)

        Qt::WindowStates a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_WindowStates(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->overrideWindowState(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for overrideWindowState";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: sizePolicy
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::sizePolicy
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QSizePolicy res =

            w->sizePolicy(

            );

        //setRecFlag(false);

        // return type: QSizePolicy

        return RJSHelper::cpp2js_QSizePolicy(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for sizePolicy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setSizePolicy
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setSizePolicy
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_QSizePolicy_Policy(handler, a1
                                        )

        && RJSHelper::is_QSizePolicy_Policy(handler, a2
                                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: horizontal (QSizePolicy::Policy)

        QSizePolicy::Policy a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QSizePolicy_Policy(handler, a1);

        // convert js parameter to cpp: vertical (QSizePolicy::Policy)

        QSizePolicy::Policy a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QSizePolicy_Policy(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setSizePolicy(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QSizePolicy(handler, a1
                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QSizePolicy)

        QSizePolicy a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QSizePolicy(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setSizePolicy(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setSizePolicy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: heightForWidth
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::heightForWidth
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->heightForWidth(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for heightForWidth";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: hasHeightForWidth
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::hasHeightForWidth
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->hasHeightForWidth(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for hasHeightForWidth";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: visibleRegion
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::visibleRegion
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QRegion res =

            w->visibleRegion(

            );

        //setRecFlag(false);

        // return type: QRegion

        return RJSHelper::cpp2js_QRegion(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for visibleRegion";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setContentsMargins
// Source: QWidget
// Static: false
// Parameters: 4
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setContentsMargins
(

    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3,
    const QJSValue&
    a4
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_int(handler, a2
                            )

        && RJSHelper::is_int(handler, a3
                            )

        && RJSHelper::is_int(handler, a4
                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: left (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: top (int)

        int a2_cpp;

        a2_cpp = RJSHelper::js2cpp_int(handler, a2);

        // convert js parameter to cpp: right (int)

        int a3_cpp;

        a3_cpp = RJSHelper::js2cpp_int(handler, a3);

        // convert js parameter to cpp: bottom (int)

        int a4_cpp;

        a4_cpp = RJSHelper::js2cpp_int(handler, a4);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setContentsMargins(
            a1_cpp
            , a2_cpp
            , a3_cpp
            , a4_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QMargins(handler, a1
                              )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: margins (QMargins)

        QMargins a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QMargins(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setContentsMargins(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setContentsMargins";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: contentsMargins
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::contentsMargins
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QMargins res =

            w->contentsMargins(

            );

        //setRecFlag(false);

        // return type: QMargins

        return RJSHelper::cpp2js_QMargins(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for contentsMargins";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: contentsRect
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::contentsRect
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QRect res =

            w->contentsRect(

            );

        //setRecFlag(false);

        // return type: QRect

        return RJSHelper::cpp2js_QRect(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for contentsRect";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: layout
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::layout
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QLayout* res =

            w->layout(

            );

        //setRecFlag(false);

        // return type: QLayout*

        return RJSHelper::cpp2js_QLayout(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for layout";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setLayout
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setLayout
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QLayout_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QLayout)


        // pointer:
        QLayout*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QLayout_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setLayout(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setLayout";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: updateGeometry
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::updateGeometry
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->updateGeometry(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for updateGeometry";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setParent
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setParent
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )

        && RJSHelper::is_Qt_WindowFlags(handler, a2
                                       )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: parent (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);

        // convert js parameter to cpp: f (Qt::WindowFlags)

        Qt::WindowFlags a2_cpp;

        a2_cpp = RJSHelper::js2cpp_Qt_WindowFlags(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setParent(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: parent (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setParent(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setParent";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: scroll
// Source: QWidget
// Static: false
// Parameters: 3
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::scroll
(

    const QJSValue&
    a1,
    const QJSValue&
    a2,
    const QJSValue&
    a3
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_int(handler, a2
                            )

        && RJSHelper::is_QRect(handler, a3
                              )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: dx (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: dy (int)

        int a2_cpp;

        a2_cpp = RJSHelper::js2cpp_int(handler, a2);

        // convert js parameter to cpp:  (QRect)

        QRect a3_cpp;

        a3_cpp = RJSHelper::js2cpp_QRect(handler, a3);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->scroll(
            a1_cpp
            , a2_cpp
            , a3_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_int(handler, a2
                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: dx (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: dy (int)

        int a2_cpp;

        a2_cpp = RJSHelper::js2cpp_int(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->scroll(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for scroll";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: focusWidget
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::focusWidget
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QWidget* res =

            w->focusWidget(

            );

        //setRecFlag(false);

        // return type: QWidget*

        return RJSHelper::cpp2js_QWidget(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for focusWidget";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: nextInFocusChain
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::nextInFocusChain
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QWidget* res =

            w->nextInFocusChain(

            );

        //setRecFlag(false);

        // return type: QWidget*

        return RJSHelper::cpp2js_QWidget(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for nextInFocusChain";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: previousInFocusChain
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::previousInFocusChain
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QWidget* res =

            w->previousInFocusChain(

            );

        //setRecFlag(false);

        // return type: QWidget*

        return RJSHelper::cpp2js_QWidget(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for previousInFocusChain";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: acceptDrops
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::acceptDrops
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->acceptDrops(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for acceptDrops";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setAcceptDrops
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setAcceptDrops
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: on (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setAcceptDrops(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAcceptDrops";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: addAction
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::addAction
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAction_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: action (QAction)


        // pointer:
        QAction*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAction_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->addAction(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for addAction";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: addActions
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::addActions
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QList_QAction_ptr(handler, a1
                                       )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: actions (QList<QAction*>)

        QList<QAction*> a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QList_QAction_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->addActions(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QList_QAction_ptr(handler, a1
                                       )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: actions (QList<QAction*>)

        QList<QAction*> a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QList_QAction_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->addActions(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for addActions";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: insertActions
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::insertActions
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAction_ptr(handler, a1
                                  , true

                                 )

        && RJSHelper::is_QList_QAction_ptr(handler, a2
                                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: before (QAction)


        // pointer:
        QAction*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAction_ptr(handler, a1);

        // convert js parameter to cpp: actions (QList<QAction*>)

        QList<QAction*> a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QList_QAction_ptr(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->insertActions(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QAction_ptr(handler, a1
                                  , true

                                 )

        && RJSHelper::is_QList_QAction_ptr(handler, a2
                                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: before (QAction)


        // pointer:
        QAction*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAction_ptr(handler, a1);

        // convert js parameter to cpp: actions (QList<QAction*>)

        QList<QAction*> a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QList_QAction_ptr(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->insertActions(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for insertActions";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: insertAction
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::insertAction
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAction_ptr(handler, a1
                                  , true

                                 )

        && RJSHelper::is_QAction_ptr(handler, a2
                                     , true

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: before (QAction)


        // pointer:
        QAction*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAction_ptr(handler, a1);

        // convert js parameter to cpp: action (QAction)


        // pointer:
        QAction*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QAction_ptr(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->insertAction(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for insertAction";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: removeAction
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::removeAction
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAction_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: action (QAction)


        // pointer:
        QAction*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAction_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->removeAction(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for removeAction";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: actions
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::actions
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QList<QAction*> res =

            w->actions(

            );

        //setRecFlag(false);

        // return type: QList<QAction*>

        return RJSHelper::cpp2js_QList_QAction_ptr(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for actions";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: parentWidget
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::parentWidget
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QWidget* res =

            w->parentWidget(

            );

        //setRecFlag(false);

        // return type: QWidget*

        return RJSHelper::cpp2js_QWidget(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for parentWidget";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setWindowFlags
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWindowFlags
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_WindowFlags(handler, a1
                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: type (Qt::WindowFlags)

        Qt::WindowFlags a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_WindowFlags(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setWindowFlags(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setWindowFlags";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: windowFlags
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::windowFlags
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        Qt::WindowFlags res =

            w->windowFlags(

            );

        //setRecFlag(false);

        // return type: Qt::WindowFlags

        return RJSHelper::cpp2js_Qt_WindowFlags(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for windowFlags";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setWindowFlag
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWindowFlag
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_WindowType(handler, a1
                                   )

        && RJSHelper::is_bool(handler, a2
                              , true

                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (Qt::WindowType)

        Qt::WindowType a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_WindowType(handler, a1);

        // convert js parameter to cpp: on (bool)

        bool a2_cpp;


        if (a2.isUndefined()) {
            a2_cpp = true;
        }
        else {
            a2_cpp = RJSHelper::js2cpp_bool(handler, a2);
        }


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setWindowFlag(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setWindowFlag";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: overrideWindowFlags
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::overrideWindowFlags
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_WindowFlags(handler, a1
                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: type (Qt::WindowFlags)

        Qt::WindowFlags a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_WindowFlags(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->overrideWindowFlags(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for overrideWindowFlags";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: windowType
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::windowType
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        Qt::WindowType res =

            w->windowType(

            );

        //setRecFlag(false);

        // return type: Qt::WindowType

        return RJSHelper::cpp2js_Qt_WindowType(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for windowType";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: childAt
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::childAt
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_int(handler, a2
                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: x (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: y (int)

        int a2_cpp;

        a2_cpp = RJSHelper::js2cpp_int(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QWidget* res =

            w->childAt(
                a1_cpp
                , a2_cpp

            );

        //setRecFlag(false);

        // return type: QWidget*

        return RJSHelper::cpp2js_QWidget(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    // check parameter types:
    if (
        RJSHelper::is_QPoint(handler, a1
                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: p (QPoint)

        QPoint a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QPoint(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QWidget* res =

            w->childAt(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QWidget*

        return RJSHelper::cpp2js_QWidget(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for childAt";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setAttribute
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setAttribute
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_WidgetAttribute(handler, a1
                                        )

        && RJSHelper::is_bool(handler, a2
                              , true

                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (Qt::WidgetAttribute)

        Qt::WidgetAttribute a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_WidgetAttribute(handler, a1);

        // convert js parameter to cpp: on (bool)

        bool a2_cpp;


        if (a2.isUndefined()) {
            a2_cpp = true;
        }
        else {
            a2_cpp = RJSHelper::js2cpp_bool(handler, a2);
        }


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setAttribute(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAttribute";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: testAttribute
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::testAttribute
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_WidgetAttribute(handler, a1
                                        )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (Qt::WidgetAttribute)

        Qt::WidgetAttribute a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_WidgetAttribute(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->testAttribute(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for testAttribute";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: ensurePolished
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::ensurePolished
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->ensurePolished(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for ensurePolished";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isAncestorOf
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isAncestorOf
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: child (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isAncestorOf(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isAncestorOf";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: autoFillBackground
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::autoFillBackground
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->autoFillBackground(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for autoFillBackground";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setAutoFillBackground
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setAutoFillBackground
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: enabled (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setAutoFillBackground(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAutoFillBackground";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: customContextMenuRequested
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QListWidget_Wrapper::customContextMenuRequestedEmitter(
    const QPoint& pos
) {
    // convert cpp parameters to js:

    // parameter: pos (QPoint)



    QJSValue a1_js = RJSHelper::cpp2js_QPoint(
                         handler,
                         pos
                     );


    emit customContextMenuRequested(
        a1_js
    );
}

// Class: QListWidget
// Function: inputMethodHints
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::inputMethodHints
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        Qt::InputMethodHints res =

            w->inputMethodHints(

            );

        //setRecFlag(false);

        // return type: Qt::InputMethodHints

        return RJSHelper::cpp2js_Qt_InputMethodHints(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for inputMethodHints";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setInputMethodHints
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setInputMethodHints
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_InputMethodHints(handler, a1
                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: hints (Qt::InputMethodHints)

        Qt::InputMethodHints a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_InputMethodHints(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setInputMethodHints(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setInputMethodHints";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: frameStyle
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::frameStyle
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->frameStyle(

            );

        //setRecFlag(false);

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for frameStyle";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setFrameStyle
// Source: QFrame
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setFrameStyle
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setFrameStyle(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setFrameStyle";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: frameWidth
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::frameWidth
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->frameWidth(

            );

        //setRecFlag(false);

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for frameWidth";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: frameShape
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::frameShape
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QFrame::Shape res =

            w->frameShape(

            );

        //setRecFlag(false);

        // return type: QFrame::Shape

        return RJSHelper::cpp2js_QFrame_Shape(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for frameShape";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setFrameShape
// Source: QFrame
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setFrameShape
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QFrame_Shape(handler, a1
                                  )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QFrame::Shape)

        QFrame::Shape a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QFrame_Shape(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setFrameShape(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setFrameShape";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: frameShadow
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::frameShadow
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QFrame::Shadow res =

            w->frameShadow(

            );

        //setRecFlag(false);

        // return type: QFrame::Shadow

        return RJSHelper::cpp2js_QFrame_Shadow(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for frameShadow";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setFrameShadow
// Source: QFrame
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setFrameShadow
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QFrame_Shadow(handler, a1
                                   )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QFrame::Shadow)

        QFrame::Shadow a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QFrame_Shadow(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setFrameShadow(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setFrameShadow";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: lineWidth
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::lineWidth
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->lineWidth(

            );

        //setRecFlag(false);

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for lineWidth";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setLineWidth
// Source: QFrame
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setLineWidth
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setLineWidth(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setLineWidth";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: midLineWidth
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::midLineWidth
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->midLineWidth(

            );

        //setRecFlag(false);

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for midLineWidth";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setMidLineWidth
// Source: QFrame
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setMidLineWidth
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setMidLineWidth(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setMidLineWidth";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: frameRect
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::frameRect
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QRect res =

            w->frameRect(

            );

        //setRecFlag(false);

        // return type: QRect

        return RJSHelper::cpp2js_QRect(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for frameRect";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setFrameRect
// Source: QFrame
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setFrameRect
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QRect(handler, a1
                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QRect)

        QRect a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QRect(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setFrameRect(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setFrameRect";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: verticalScrollBarPolicy
// Source: QAbstractScrollArea
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::verticalScrollBarPolicy
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        Qt::ScrollBarPolicy res =

            w->verticalScrollBarPolicy(

            );

        //setRecFlag(false);

        // return type: Qt::ScrollBarPolicy

        return RJSHelper::cpp2js_Qt_ScrollBarPolicy(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for verticalScrollBarPolicy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setVerticalScrollBarPolicy
// Source: QAbstractScrollArea
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setVerticalScrollBarPolicy
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_ScrollBarPolicy(handler, a1
                                        )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (Qt::ScrollBarPolicy)

        Qt::ScrollBarPolicy a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_ScrollBarPolicy(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setVerticalScrollBarPolicy(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setVerticalScrollBarPolicy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: verticalScrollBar
// Source: QAbstractScrollArea
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::verticalScrollBar
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QScrollBar* res =

            w->verticalScrollBar(

            );

        //setRecFlag(false);

        // return type: QScrollBar*

        return RJSHelper::cpp2js_QScrollBar(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for verticalScrollBar";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setVerticalScrollBar
// Source: QAbstractScrollArea
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setVerticalScrollBar
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QScrollBar_ptr(handler, a1
                                     , true

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: scrollbar (QScrollBar)


        // pointer:
        QScrollBar*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QScrollBar_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setVerticalScrollBar(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setVerticalScrollBar";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: horizontalScrollBarPolicy
// Source: QAbstractScrollArea
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::horizontalScrollBarPolicy
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        Qt::ScrollBarPolicy res =

            w->horizontalScrollBarPolicy(

            );

        //setRecFlag(false);

        // return type: Qt::ScrollBarPolicy

        return RJSHelper::cpp2js_Qt_ScrollBarPolicy(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for horizontalScrollBarPolicy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setHorizontalScrollBarPolicy
// Source: QAbstractScrollArea
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setHorizontalScrollBarPolicy
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_ScrollBarPolicy(handler, a1
                                        )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (Qt::ScrollBarPolicy)

        Qt::ScrollBarPolicy a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_ScrollBarPolicy(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setHorizontalScrollBarPolicy(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setHorizontalScrollBarPolicy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: horizontalScrollBar
// Source: QAbstractScrollArea
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::horizontalScrollBar
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QScrollBar* res =

            w->horizontalScrollBar(

            );

        //setRecFlag(false);

        // return type: QScrollBar*

        return RJSHelper::cpp2js_QScrollBar(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for horizontalScrollBar";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setHorizontalScrollBar
// Source: QAbstractScrollArea
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setHorizontalScrollBar
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QScrollBar_ptr(handler, a1
                                     , true

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: scrollbar (QScrollBar)


        // pointer:
        QScrollBar*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QScrollBar_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setHorizontalScrollBar(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setHorizontalScrollBar";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: cornerWidget
// Source: QAbstractScrollArea
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::cornerWidget
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QWidget* res =

            w->cornerWidget(

            );

        //setRecFlag(false);

        // return type: QWidget*

        return RJSHelper::cpp2js_QWidget(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for cornerWidget";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setCornerWidget
// Source: QAbstractScrollArea
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setCornerWidget
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: widget (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setCornerWidget(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setCornerWidget";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: addScrollBarWidget
// Source: QAbstractScrollArea
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::addScrollBarWidget
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )

        && RJSHelper::is_Qt_Alignment(handler, a2
                                     )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: widget (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);

        // convert js parameter to cpp: alignment (Qt::Alignment)

        Qt::Alignment a2_cpp;

        a2_cpp = RJSHelper::js2cpp_Qt_Alignment(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->addScrollBarWidget(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for addScrollBarWidget";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: viewport
// Source: QAbstractScrollArea
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::viewport
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QWidget* res =

            w->viewport(

            );

        //setRecFlag(false);

        // return type: QWidget*

        return RJSHelper::cpp2js_QWidget(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for viewport";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setViewport
// Source: QAbstractScrollArea
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setViewport
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: widget (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setViewport(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setViewport";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: maximumViewportSize
// Source: QAbstractScrollArea
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::maximumViewportSize
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QSize res =

            w->maximumViewportSize(

            );

        //setRecFlag(false);

        // return type: QSize

        return RJSHelper::cpp2js_QSize(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for maximumViewportSize";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: minimumSizeHint
// Source: QAbstractScrollArea
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::minimumSizeHint
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QSize res =

            w->minimumSizeHint(

            );

        //setRecFlag(false);

        // return type: QSize

        return RJSHelper::cpp2js_QSize(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for minimumSizeHint";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: sizeHint
// Source: QAbstractScrollArea
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::sizeHint
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QSize res =

            w->sizeHint(

            );

        //setRecFlag(false);

        // return type: QSize

        return RJSHelper::cpp2js_QSize(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for sizeHint";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setupViewport
// Source: QAbstractScrollArea
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setupViewport
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QWidget_ptr(handler, a1
                                  , true

                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: viewport (QWidget)


        // pointer:
        QWidget*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setupViewport(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setupViewport";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: sizeAdjustPolicy
// Source: QAbstractScrollArea
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::sizeAdjustPolicy
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QAbstractScrollArea::SizeAdjustPolicy res =

            w->sizeAdjustPolicy(

            );

        //setRecFlag(false);

        // return type: QAbstractScrollArea::SizeAdjustPolicy

        return RJSHelper::cpp2js_QAbstractScrollArea_SizeAdjustPolicy(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for sizeAdjustPolicy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setSizeAdjustPolicy
// Source: QAbstractScrollArea
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setSizeAdjustPolicy
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAbstractScrollArea_SizeAdjustPolicy(handler, a1
                                                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: policy (QAbstractScrollArea::SizeAdjustPolicy)

        QAbstractScrollArea::SizeAdjustPolicy a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAbstractScrollArea_SizeAdjustPolicy(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setSizeAdjustPolicy(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setSizeAdjustPolicy";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: model
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::model
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QAbstractItemModel* res =

            w->model(

            );

        //setRecFlag(false);

        // return type: QAbstractItemModel*

        return RJSHelper::cpp2js_QAbstractItemModel(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for model";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setSelectionModel
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setSelectionModel
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QItemSelectionModel_ptr(handler, a1
                , true

                                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: selectionModel (QItemSelectionModel)


        // pointer:
        QItemSelectionModel*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QItemSelectionModel_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setSelectionModel(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setSelectionModel";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: selectionModel
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::selectionModel
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QItemSelectionModel* res =

            w->selectionModel(

            );

        //setRecFlag(false);

        // return type: QItemSelectionModel*

        return RJSHelper::cpp2js_QItemSelectionModel(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for selectionModel";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setItemDelegate
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setItemDelegate
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAbstractItemDelegate_ptr(handler, a1
                , true

                                               )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: delegate (QAbstractItemDelegate)


        // pointer:
        QAbstractItemDelegate*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAbstractItemDelegate_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setItemDelegate(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setItemDelegate";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setSelectionMode
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setSelectionMode
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAbstractItemView_SelectionMode(handler, a1
                                                     )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: mode (QAbstractItemView::SelectionMode)

        QAbstractItemView::SelectionMode a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAbstractItemView_SelectionMode(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setSelectionMode(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setSelectionMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: selectionMode
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::selectionMode
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QAbstractItemView::SelectionMode res =

            w->selectionMode(

            );

        //setRecFlag(false);

        // return type: QAbstractItemView::SelectionMode

        return RJSHelper::cpp2js_QAbstractItemView_SelectionMode(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for selectionMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setSelectionBehavior
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setSelectionBehavior
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAbstractItemView_SelectionBehavior(handler, a1
                                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: behavior (QAbstractItemView::SelectionBehavior)

        QAbstractItemView::SelectionBehavior a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAbstractItemView_SelectionBehavior(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setSelectionBehavior(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setSelectionBehavior";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: selectionBehavior
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::selectionBehavior
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QAbstractItemView::SelectionBehavior res =

            w->selectionBehavior(

            );

        //setRecFlag(false);

        // return type: QAbstractItemView::SelectionBehavior

        return RJSHelper::cpp2js_QAbstractItemView_SelectionBehavior(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for selectionBehavior";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: currentIndex
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::currentIndex
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QModelIndex res =

            w->currentIndex(

            );

        //setRecFlag(false);

        // return type: QModelIndex

        return RJSHelper::cpp2js_QModelIndex(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for currentIndex";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: rootIndex
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::rootIndex
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QModelIndex res =

            w->rootIndex(

            );

        //setRecFlag(false);

        // return type: QModelIndex

        return RJSHelper::cpp2js_QModelIndex(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for rootIndex";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setEditTriggers
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setEditTriggers
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAbstractItemView_EditTriggers(handler, a1
                                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: triggers (QAbstractItemView::EditTriggers)

        QAbstractItemView::EditTriggers a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAbstractItemView_EditTriggers(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setEditTriggers(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setEditTriggers";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: editTriggers
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::editTriggers
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QAbstractItemView::EditTriggers res =

            w->editTriggers(

            );

        //setRecFlag(false);

        // return type: QAbstractItemView::EditTriggers

        return RJSHelper::cpp2js_QAbstractItemView_EditTriggers(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for editTriggers";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setVerticalScrollMode
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setVerticalScrollMode
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAbstractItemView_ScrollMode(handler, a1
                                                  )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: mode (QAbstractItemView::ScrollMode)

        QAbstractItemView::ScrollMode a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAbstractItemView_ScrollMode(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setVerticalScrollMode(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setVerticalScrollMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: verticalScrollMode
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::verticalScrollMode
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QAbstractItemView::ScrollMode res =

            w->verticalScrollMode(

            );

        //setRecFlag(false);

        // return type: QAbstractItemView::ScrollMode

        return RJSHelper::cpp2js_QAbstractItemView_ScrollMode(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for verticalScrollMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: resetVerticalScrollMode
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::resetVerticalScrollMode
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->resetVerticalScrollMode(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for resetVerticalScrollMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setHorizontalScrollMode
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setHorizontalScrollMode
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAbstractItemView_ScrollMode(handler, a1
                                                  )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: mode (QAbstractItemView::ScrollMode)

        QAbstractItemView::ScrollMode a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAbstractItemView_ScrollMode(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setHorizontalScrollMode(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setHorizontalScrollMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: horizontalScrollMode
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::horizontalScrollMode
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QAbstractItemView::ScrollMode res =

            w->horizontalScrollMode(

            );

        //setRecFlag(false);

        // return type: QAbstractItemView::ScrollMode

        return RJSHelper::cpp2js_QAbstractItemView_ScrollMode(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for horizontalScrollMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: resetHorizontalScrollMode
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::resetHorizontalScrollMode
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->resetHorizontalScrollMode(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for resetHorizontalScrollMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setAutoScroll
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setAutoScroll
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: enable (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setAutoScroll(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAutoScroll";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: hasAutoScroll
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::hasAutoScroll
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->hasAutoScroll(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for hasAutoScroll";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setAutoScrollMargin
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setAutoScrollMargin
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: margin (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setAutoScrollMargin(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAutoScrollMargin";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: autoScrollMargin
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::autoScrollMargin
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->autoScrollMargin(

            );

        //setRecFlag(false);

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for autoScrollMargin";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setTabKeyNavigation
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setTabKeyNavigation
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: enable (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setTabKeyNavigation(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setTabKeyNavigation";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: tabKeyNavigation
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::tabKeyNavigation
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->tabKeyNavigation(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for tabKeyNavigation";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setDropIndicatorShown
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setDropIndicatorShown
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: enable (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setDropIndicatorShown(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setDropIndicatorShown";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: showDropIndicator
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::showDropIndicator
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->showDropIndicator(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for showDropIndicator";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setDragEnabled
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setDragEnabled
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: enable (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setDragEnabled(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setDragEnabled";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: dragEnabled
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::dragEnabled
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->dragEnabled(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for dragEnabled";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setDragDropOverwriteMode
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setDragDropOverwriteMode
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: overwrite (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setDragDropOverwriteMode(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setDragDropOverwriteMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: dragDropOverwriteMode
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::dragDropOverwriteMode
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->dragDropOverwriteMode(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for dragDropOverwriteMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setDragDropMode
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setDragDropMode
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QAbstractItemView_DragDropMode(handler, a1
                                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: behavior (QAbstractItemView::DragDropMode)

        QAbstractItemView::DragDropMode a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QAbstractItemView_DragDropMode(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setDragDropMode(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setDragDropMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: dragDropMode
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::dragDropMode
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QAbstractItemView::DragDropMode res =

            w->dragDropMode(

            );

        //setRecFlag(false);

        // return type: QAbstractItemView::DragDropMode

        return RJSHelper::cpp2js_QAbstractItemView_DragDropMode(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for dragDropMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setDefaultDropAction
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setDefaultDropAction
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_DropAction(handler, a1
                                   )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: dropAction (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();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setDefaultDropAction(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setDefaultDropAction";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: defaultDropAction
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::defaultDropAction
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        Qt::DropAction res =

            w->defaultDropAction(

            );

        //setRecFlag(false);

        // return type: Qt::DropAction

        return RJSHelper::cpp2js_Qt_DropAction(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for defaultDropAction";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setAlternatingRowColors
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setAlternatingRowColors
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: enable (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setAlternatingRowColors(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setAlternatingRowColors";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: alternatingRowColors
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::alternatingRowColors
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->alternatingRowColors(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for alternatingRowColors";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setIconSize
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setIconSize
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QSize(handler, a1
                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: size (QSize)

        QSize a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QSize(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setIconSize(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setIconSize";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: iconSize
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::iconSize
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QSize res =

            w->iconSize(

            );

        //setRecFlag(false);

        // return type: QSize

        return RJSHelper::cpp2js_QSize(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for iconSize";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setTextElideMode
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setTextElideMode
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_TextElideMode(handler, a1
                                      )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: mode (Qt::TextElideMode)

        Qt::TextElideMode a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_TextElideMode(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setTextElideMode(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setTextElideMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: textElideMode
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::textElideMode
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        Qt::TextElideMode res =

            w->textElideMode(

            );

        //setRecFlag(false);

        // return type: Qt::TextElideMode

        return RJSHelper::cpp2js_Qt_TextElideMode(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for textElideMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: keyboardSearch
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::keyboardSearch
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: search (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->keyboardSearch(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for keyboardSearch";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setIndexWidget
// Source: QAbstractItemView
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setIndexWidget
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_QModelIndex(handler, a1
                                 )

        && RJSHelper::is_QWidget_ptr(handler, a2
                                     , true

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: index (QModelIndex)

        QModelIndex a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QModelIndex(handler, a1);

        // convert js parameter to cpp: widget (QWidget)


        // pointer:
        QWidget*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setIndexWidget(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setIndexWidget";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: indexWidget
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::indexWidget
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QModelIndex(handler, a1
                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: index (QModelIndex)

        QModelIndex a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QModelIndex(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QWidget* res =

            w->indexWidget(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QWidget*

        return RJSHelper::cpp2js_QWidget(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for indexWidget";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: inputMethodQuery
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::inputMethodQuery
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_InputMethodQuery(handler, a1
                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: query (Qt::InputMethodQuery)

        Qt::InputMethodQuery a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_InputMethodQuery(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QVariant res =

            w->inputMethodQuery(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QVariant

        return RJSHelper::cpp2js_QVariant(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for inputMethodQuery";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: selectAll
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::selectAll
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->selectAll(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for selectAll";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: edit
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::edit
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QModelIndex(handler, a1
                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: index (QModelIndex)

        QModelIndex a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QModelIndex(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->edit(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for edit";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: clearSelection
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::clearSelection
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->clearSelection(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for clearSelection";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setCurrentIndex
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setCurrentIndex
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QModelIndex(handler, a1
                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: index (QModelIndex)

        QModelIndex a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QModelIndex(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setCurrentIndex(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setCurrentIndex";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: scrollToTop
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::scrollToTop
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->scrollToTop(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for scrollToTop";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: scrollToBottom
// Source: QAbstractItemView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::scrollToBottom
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->scrollToBottom(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for scrollToBottom";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: update
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::update
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QModelIndex(handler, a1
                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: index (QModelIndex)

        QModelIndex a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QModelIndex(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->update(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for update";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: doubleClicked
// Source: QAbstractItemView
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QListWidget_Wrapper::doubleClickedEmitter(
    const QModelIndex& index
) {
    // convert cpp parameters to js:

    // parameter: index (QModelIndex)



    QJSValue a1_js = RJSHelper::cpp2js_QModelIndex(
                         handler,
                         index
                     );


    emit doubleClicked(
        a1_js
    );
}

// Class: QListWidget
// Function: setMovement
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setMovement
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QListView_Movement(handler, a1
                                        )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: movement (QListView::Movement)

        QListView::Movement a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListView_Movement(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setMovement(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setMovement";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: movement
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::movement
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QListView::Movement res =

            w->movement(

            );

        //setRecFlag(false);

        // return type: QListView::Movement

        return RJSHelper::cpp2js_QListView_Movement(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for movement";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setFlow
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setFlow
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QListView_Flow(handler, a1
                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: flow (QListView::Flow)

        QListView::Flow a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListView_Flow(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setFlow(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setFlow";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: flow
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::flow
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QListView::Flow res =

            w->flow(

            );

        //setRecFlag(false);

        // return type: QListView::Flow

        return RJSHelper::cpp2js_QListView_Flow(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for flow";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setWrapping
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWrapping
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: enable (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setWrapping(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setWrapping";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isWrapping
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isWrapping
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isWrapping(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isWrapping";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setResizeMode
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setResizeMode
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QListView_ResizeMode(handler, a1
                                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: mode (QListView::ResizeMode)

        QListView::ResizeMode a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListView_ResizeMode(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setResizeMode(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setResizeMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: resizeMode
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::resizeMode
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QListView::ResizeMode res =

            w->resizeMode(

            );

        //setRecFlag(false);

        // return type: QListView::ResizeMode

        return RJSHelper::cpp2js_QListView_ResizeMode(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for resizeMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setLayoutMode
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setLayoutMode
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QListView_LayoutMode(handler, a1
                                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: mode (QListView::LayoutMode)

        QListView::LayoutMode a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListView_LayoutMode(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setLayoutMode(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setLayoutMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: layoutMode
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::layoutMode
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QListView::LayoutMode res =

            w->layoutMode(

            );

        //setRecFlag(false);

        // return type: QListView::LayoutMode

        return RJSHelper::cpp2js_QListView_LayoutMode(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for layoutMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setSpacing
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setSpacing
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: space (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setSpacing(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setSpacing";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: spacing
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::spacing
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->spacing(

            );

        //setRecFlag(false);

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for spacing";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setBatchSize
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setBatchSize
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: batchSize (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setBatchSize(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setBatchSize";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: batchSize
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::batchSize
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->batchSize(

            );

        //setRecFlag(false);

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for batchSize";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setGridSize
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setGridSize
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QSize(handler, a1
                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: size (QSize)

        QSize a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QSize(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setGridSize(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setGridSize";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: gridSize
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::gridSize
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QSize res =

            w->gridSize(

            );

        //setRecFlag(false);

        // return type: QSize

        return RJSHelper::cpp2js_QSize(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for gridSize";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setViewMode
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setViewMode
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QListView_ViewMode(handler, a1
                                        )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: mode (QListView::ViewMode)

        QListView::ViewMode a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListView_ViewMode(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setViewMode(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setViewMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: viewMode
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::viewMode
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QListView::ViewMode res =

            w->viewMode(

            );

        //setRecFlag(false);

        // return type: QListView::ViewMode

        return RJSHelper::cpp2js_QListView_ViewMode(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for viewMode";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: clearPropertyFlags
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::clearPropertyFlags
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->clearPropertyFlags(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for clearPropertyFlags";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isRowHidden
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isRowHidden
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: row (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isRowHidden(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isRowHidden";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setRowHidden
// Source: QListView
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setRowHidden
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_bool(handler, a2
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: row (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: hide (bool)

        bool a2_cpp;

        a2_cpp = RJSHelper::js2cpp_bool(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setRowHidden(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setRowHidden";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setModelColumn
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setModelColumn
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: column (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setModelColumn(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setModelColumn";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: modelColumn
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::modelColumn
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->modelColumn(

            );

        //setRecFlag(false);

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for modelColumn";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setUniformItemSizes
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setUniformItemSizes
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: enable (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setUniformItemSizes(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setUniformItemSizes";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: uniformItemSizes
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::uniformItemSizes
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->uniformItemSizes(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for uniformItemSizes";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setWordWrap
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setWordWrap
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: on (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setWordWrap(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setWordWrap";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: wordWrap
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::wordWrap
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->wordWrap(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for wordWrap";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setSelectionRectVisible
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setSelectionRectVisible
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: show (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setSelectionRectVisible(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setSelectionRectVisible";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isSelectionRectVisible
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isSelectionRectVisible
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isSelectionRectVisible(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isSelectionRectVisible";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setItemAlignment
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setItemAlignment
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_Alignment(handler, a1
                                  )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: alignment (Qt::Alignment)

        Qt::Alignment a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_Alignment(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setItemAlignment(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setItemAlignment";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: itemAlignment
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::itemAlignment
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        Qt::Alignment res =

            w->itemAlignment(

            );

        //setRecFlag(false);

        // return type: Qt::Alignment

        return RJSHelper::cpp2js_Qt_Alignment(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for itemAlignment";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: visualRect
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::visualRect
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QModelIndex(handler, a1
                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: index (QModelIndex)

        QModelIndex a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QModelIndex(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QRect res =

            w->visualRect(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QRect

        return RJSHelper::cpp2js_QRect(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for visualRect";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: scrollTo
// Source: QListView
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::scrollTo
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_QModelIndex(handler, a1
                                 )

        && RJSHelper::is_QAbstractItemView_ScrollHint(handler, a2
                , true

                                                     )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: index (QModelIndex)

        QModelIndex a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QModelIndex(handler, a1);

        // convert js parameter to cpp: hint (QAbstractItemView::ScrollHint)

        QAbstractItemView::ScrollHint a2_cpp;


        if (a2.isUndefined()) {
            a2_cpp = QAbstractItemView::EnsureVisible;
        }
        else {
            a2_cpp = RJSHelper::js2cpp_QAbstractItemView_ScrollHint(handler, a2);
        }


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->scrollTo(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for scrollTo";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: indexAt
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::indexAt
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QPoint(handler, a1
                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: p (QPoint)

        QPoint a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QPoint(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QModelIndex res =

            w->indexAt(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QModelIndex

        return RJSHelper::cpp2js_QModelIndex(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for indexAt";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: doItemsLayout
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::doItemsLayout
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->doItemsLayout(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for doItemsLayout";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: reset
// Source: QListView
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::reset
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->reset(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for reset";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setRootIndex
// Source: QListView
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setRootIndex
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QModelIndex(handler, a1
                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: index (QModelIndex)

        QModelIndex a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QModelIndex(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setRootIndex(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setRootIndex";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: item
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::item
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: row (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QListWidgetItem* res =

            w->item(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QListWidgetItem*

        return RJSHelper::cpp2js_QListWidgetItem(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for item";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: row
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::row
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QListWidgetItem_ptr(handler, a1
                                          , true

                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->row(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for row";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: insertItem
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::insertItem
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_QListWidgetItem_ptr(handler, a2
                , true

                                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: row (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->insertItem(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_QString(handler, a2
                                )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: row (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: label (QString)

        QString a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QString(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->insertItem(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for insertItem";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: insertItems
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::insertItems
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_QStringList(handler, a2
                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: row (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: labels (QStringList)

        QStringList a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QStringList(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->insertItems(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for insertItems";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: addItem
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::addItem
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: label (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->addItem(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    // check parameter types:
    if (
        RJSHelper::is_QListWidgetItem_ptr(handler, a1
                                          , true

                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->addItem(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for addItem";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: addItems
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::addItems
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QStringList(handler, a1
                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: labels (QStringList)

        QStringList a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QStringList(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->addItems(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for addItems";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: takeItem
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::takeItem
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: row (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QListWidgetItem* res =

            w->takeItem(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QListWidgetItem*

        return RJSHelper::cpp2js_QListWidgetItem(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for takeItem";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: count
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::count
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->count(

            );

        //setRecFlag(false);

        // 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: QListWidget
// Function: currentItem
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::currentItem
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QListWidgetItem* res =

            w->currentItem(

            );

        //setRecFlag(false);

        // return type: QListWidgetItem*

        return RJSHelper::cpp2js_QListWidgetItem(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for currentItem";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setCurrentItem
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setCurrentItem
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QListWidgetItem_ptr(handler, a1
                                          , true

                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setCurrentItem(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setCurrentItem";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: currentRow
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::currentRow
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        int res =

            w->currentRow(

            );

        //setRecFlag(false);

        // return type: int

        return RJSHelper::cpp2js_int(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for currentRow";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setCurrentRow
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setCurrentRow
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: row (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setCurrentRow(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setCurrentRow";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: itemAt
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::itemAt
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_int(handler, a1
                         )

        && RJSHelper::is_int(handler, a2
                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: x (int)

        int a1_cpp;

        a1_cpp = RJSHelper::js2cpp_int(handler, a1);

        // convert js parameter to cpp: y (int)

        int a2_cpp;

        a2_cpp = RJSHelper::js2cpp_int(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QListWidgetItem* res =

            w->itemAt(
                a1_cpp
                , a2_cpp

            );

        //setRecFlag(false);

        // return type: QListWidgetItem*

        return RJSHelper::cpp2js_QListWidgetItem(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    // check parameter types:
    if (
        RJSHelper::is_QPoint(handler, a1
                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: p (QPoint)

        QPoint a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QPoint(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QListWidgetItem* res =

            w->itemAt(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QListWidgetItem*

        return RJSHelper::cpp2js_QListWidgetItem(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for itemAt";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: visualItemRect
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::visualItemRect
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QListWidgetItem_ptr(handler, a1
                                          , true

                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QRect res =

            w->visualItemRect(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QRect

        return RJSHelper::cpp2js_QRect(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for visualItemRect";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: sortItems
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::sortItems
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_Qt_SortOrder(handler, a1
                                   , true

                                  )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: order (Qt::SortOrder)

        Qt::SortOrder a1_cpp;


        if (a1.isUndefined()) {
            a1_cpp = Qt::AscendingOrder;
        }
        else {
            a1_cpp = RJSHelper::js2cpp_Qt_SortOrder(handler, a1);
        }


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->sortItems(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for sortItems";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setSortingEnabled
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setSortingEnabled
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_bool(handler, a1
                          )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: enable (bool)

        bool a1_cpp;

        a1_cpp = RJSHelper::js2cpp_bool(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setSortingEnabled(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setSortingEnabled";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isSortingEnabled
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isSortingEnabled
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isSortingEnabled(

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isSortingEnabled";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: editItem
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::editItem
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QListWidgetItem_ptr(handler, a1
                                          , true

                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->editItem(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for editItem";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: openPersistentEditor
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::openPersistentEditor
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QListWidgetItem_ptr(handler, a1
                                          , true

                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->openPersistentEditor(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for openPersistentEditor";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: closePersistentEditor
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::closePersistentEditor
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QListWidgetItem_ptr(handler, a1
                                          , true

                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->closePersistentEditor(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for closePersistentEditor";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: isPersistentEditorOpen
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::isPersistentEditorOpen
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QListWidgetItem_ptr(handler, a1
                                          , true

                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        bool res =

            w->isPersistentEditorOpen(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: bool

        return RJSHelper::cpp2js_bool(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for isPersistentEditorOpen";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: itemWidget
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::itemWidget
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QListWidgetItem_ptr(handler, a1
                                          , true

                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QWidget* res =

            w->itemWidget(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QWidget*

        return RJSHelper::cpp2js_QWidget(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for itemWidget";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: setItemWidget
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::setItemWidget
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_QListWidgetItem_ptr(handler, a1
                                          , true

                                         )

        && RJSHelper::is_QWidget_ptr(handler, a2
                                     , true

                                    )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a1);

        // convert js parameter to cpp: widget (QWidget)


        // pointer:
        QWidget*
        a2_cpp;

        a2_cpp = RJSHelper::js2cpp_QWidget_ptr(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->setItemWidget(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for setItemWidget";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: removeItemWidget
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::removeItemWidget
(

    const QJSValue&
    a1
)

{

    // check parameter types:
    if (
        RJSHelper::is_QListWidgetItem_ptr(handler, a1
                                          , true

                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->removeItemWidget(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for removeItemWidget";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: selectedItems
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::selectedItems
(

)

const

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QList<QListWidgetItem*> res =

            w->selectedItems(

            );

        //setRecFlag(false);

        // return type: QList<QListWidgetItem*>

        return RJSHelper::cpp2js_QList_QListWidgetItem_ptr(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for selectedItems";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: findItems
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::findItems
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QString(handler, a1
                             )

        && RJSHelper::is_Qt_MatchFlags(handler, a2
                                      )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: text (QString)

        QString a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QString(handler, a1);

        // convert js parameter to cpp: flags (Qt::MatchFlags)

        Qt::MatchFlags a2_cpp;

        a2_cpp = RJSHelper::js2cpp_Qt_MatchFlags(handler, a2);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QList<QListWidgetItem*> res =

            w->findItems(
                a1_cpp
                , a2_cpp

            );

        //setRecFlag(false);

        // return type: QList<QListWidgetItem*>

        return RJSHelper::cpp2js_QList_QListWidgetItem_ptr(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for findItems";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: items
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::items
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QMimeData_ptr(handler, a1
                                    , true

                                   )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: data (QMimeData)


        // pointer:
        QMimeData*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QMimeData_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QList<QListWidgetItem*> res =

            w->items(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QList<QListWidgetItem*>

        return RJSHelper::cpp2js_QList_QListWidgetItem_ptr(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for items";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: indexFromItem
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::indexFromItem
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QListWidgetItem_ptr(handler, a1
                                          , true

                                         )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QModelIndex res =

            w->indexFromItem(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QModelIndex

        return RJSHelper::cpp2js_QModelIndex(
                   handler,
                   // non-copyable: false
                   res

               );

    }

    qWarning() << "no matching function variant found for indexFromItem";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: itemFromIndex
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::itemFromIndex
(

    const QJSValue&
    a1
)

const

{

    // check parameter types:
    if (
        RJSHelper::is_QModelIndex(handler, a1
                                 )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: index (QModelIndex)

        QModelIndex a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QModelIndex(handler, a1);


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();
        QListWidgetItem* res =

            w->itemFromIndex(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QListWidgetItem*

        return RJSHelper::cpp2js_QListWidgetItem(
                   handler,
                   // non-copyable: true
                   res

               );

    }

    qWarning() << "no matching function variant found for itemFromIndex";
    handler.trace();
    return QJSValue();

}

#if QT_CONFIG(draganddrop)

#endif

// Class: QListWidget
// Function: scrollToItem
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::scrollToItem
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

    // check parameter types:
    if (
        RJSHelper::is_QListWidgetItem_ptr(handler, a1
                                          , true

                                         )

        && RJSHelper::is_QAbstractItemView_ScrollHint(handler, a2
                , true

                                                     )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: item (QListWidgetItem)


        // pointer:
        QListWidgetItem*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QListWidgetItem_ptr(handler, a1);

        // convert js parameter to cpp: hint (QAbstractItemView::ScrollHint)

        QAbstractItemView::ScrollHint a2_cpp;


        if (a2.isUndefined()) {
            a2_cpp = QAbstractItemView::EnsureVisible;
        }
        else {
            a2_cpp = RJSHelper::js2cpp_QAbstractItemView_ScrollHint(handler, a2);
        }


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->scrollToItem(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for scrollToItem";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: clear
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QListWidget_Wrapper::clear
(

)

{

    {


        // call function:

        if (!hasWrapped()) {
            qWarning() << "wrapped is NULL";
            handler.trace();
            return QJSValue();
        }


        //setRecFlag(true);

        // non-static member function:
        // call function of wrapped object:

        // call function of C++ class:
        QListWidget* w = getWrapped();

        w->clear(

        );

        //setRecFlag(false);

        return QJSValue();

    }

    qWarning() << "no matching function variant found for clear";
    handler.trace();
    return QJSValue();

}

// Class: QListWidget
// Function: itemPressed
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QListWidget_Wrapper::itemPressedEmitter(
    QListWidgetItem* item
) {
    // convert cpp parameters to js:

    // parameter: item (QListWidgetItem)



    QJSValue a1_js = RJSHelper::cpp2js_QListWidgetItem(
                         handler,
                         item
                     );


    emit itemPressed(
        a1_js
    );
}

// Class: QListWidget
// Function: itemClicked
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QListWidget_Wrapper::itemClickedEmitter(
    QListWidgetItem* item
) {
    // convert cpp parameters to js:

    // parameter: item (QListWidgetItem)



    QJSValue a1_js = RJSHelper::cpp2js_QListWidgetItem(
                         handler,
                         item
                     );


    emit itemClicked(
        a1_js
    );
}

// Class: QListWidget
// Function: itemDoubleClicked
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QListWidget_Wrapper::itemDoubleClickedEmitter(
    QListWidgetItem* item
) {
    // convert cpp parameters to js:

    // parameter: item (QListWidgetItem)



    QJSValue a1_js = RJSHelper::cpp2js_QListWidgetItem(
                         handler,
                         item
                     );


    emit itemDoubleClicked(
        a1_js
    );
}

// Class: QListWidget
// Function: itemActivated
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QListWidget_Wrapper::itemActivatedEmitter(
    QListWidgetItem* item
) {
    // convert cpp parameters to js:

    // parameter: item (QListWidgetItem)



    QJSValue a1_js = RJSHelper::cpp2js_QListWidgetItem(
                         handler,
                         item
                     );


    emit itemActivated(
        a1_js
    );
}

// Class: QListWidget
// Function: itemEntered
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QListWidget_Wrapper::itemEnteredEmitter(
    QListWidgetItem* item
) {
    // convert cpp parameters to js:

    // parameter: item (QListWidgetItem)



    QJSValue a1_js = RJSHelper::cpp2js_QListWidgetItem(
                         handler,
                         item
                     );


    emit itemEntered(
        a1_js
    );
}

// Class: QListWidget
// Function: itemChanged
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QListWidget_Wrapper::itemChangedEmitter(
    QListWidgetItem* item
) {
    // convert cpp parameters to js:

    // parameter: item (QListWidgetItem)



    QJSValue a1_js = RJSHelper::cpp2js_QListWidgetItem(
                         handler,
                         item
                     );


    emit itemChanged(
        a1_js
    );
}

// Class: QListWidget
// Function: currentItemChanged
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QListWidget_Wrapper::currentItemChangedEmitter(
    QListWidgetItem* current, QListWidgetItem* previous
) {
    // convert cpp parameters to js:

    // parameter: current (QListWidgetItem)



    QJSValue a1_js = RJSHelper::cpp2js_QListWidgetItem(
                         handler,
                         current
                     );

    // parameter: previous (QListWidgetItem)



    QJSValue a2_js = RJSHelper::cpp2js_QListWidgetItem(
                         handler,
                         previous
                     );


    emit currentItemChanged(
        a1_js, a2_js
    );
}

// Class: QListWidget
// Function: currentTextChanged
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QListWidget_Wrapper::currentTextChangedEmitter(
    const QString& currentText
) {
    // convert cpp parameters to js:

    // parameter: currentText (QString)



    QJSValue a1_js = RJSHelper::cpp2js_QString(
                         handler,
                         currentText
                     );


    emit currentTextChanged(
        a1_js
    );
}

// Class: QListWidget
// Function: currentRowChanged
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QListWidget_Wrapper::currentRowChangedEmitter(
    int currentRow
) {
    // convert cpp parameters to js:

    // parameter: currentRow (int)



    QJSValue a1_js = RJSHelper::cpp2js_int(
                         handler,
                         currentRow
                     );


    emit currentRowChanged(
        a1_js
    );
}

// Class: QListWidget
// Function: itemSelectionChanged
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QListWidget_Wrapper::itemSelectionChangedEmitter(

) {
    // convert cpp parameters to js:


    emit itemSelectionChanged(

    );
}

#if QT_CONFIG(draganddrop)

#endif


// member functions for static properties, forward to static function



// protected overwritten functions / events and their public invokable counterparts:

