
// Auto generated

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

#include "qlabel_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QLabel*> QLabel_Wrapper::basecasters_QLabel;

// static functions implementation in singleton wrapper:

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

QJSValue
QLabel_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: QLabel
// Function: setTabOrder
// Source: QWidget
// Static: true
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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: QLabel
// Function: mouseGrabber
// Source: QWidget
// Static: true
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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: QLabel
// Function: keyboardGrabber
// Source: QWidget
// Static: true
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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_DEPRECATED_SINCE(6,6)

#endif

#ifndef QT_NO_PICTURE

#if QT_DEPRECATED_SINCE(6,6)

#endif

#endif

#if QT_CONFIG(movie)

#endif

#ifndef QT_NO_SHORTCUT

#endif

#ifndef QT_NO_PICTURE

#endif

#if QT_CONFIG(movie)

#endif

#ifndef QT_NO_CONTEXTMENU

#endif

#if QT_CONFIG(movie)

#endif

#ifndef QT_NO_SHORTCUT

#endif

void QLabel_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

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

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

*/


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

    // signal forwarding:
    initConnections();
}


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

    //qDebug() << "QLabel_Wrapper::~QLabel_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 QLabel";

    }

}

// initialization of signal forwarding

void QLabel_Wrapper::initConnections() {

    //setObjectName("QLabel_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(linkActivated(const QString&)),
            this,
            SLOT(linkActivatedEmitter(const QString&))
        );

        connect(
            getWrapped(),
            SIGNAL(linkHovered(const QString&)),
            this,
            SLOT(linkHoveredEmitter(const QString&))
        );

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

    }
}


// constructors:

// Class: QLabel
// Function:
// Source:
// Static: false
// Parameters: 3
// preceding Parameters: -1
QLabel_Wrapper::QLabel_Wrapper

(

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

    : RJSWrapperObj(*(RJSApi*)h)

{

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

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

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

                                    )

        && RJSHelper::is_Qt_WindowFlags(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 (QWidget)


        // pointer:
        QWidget*
        a2_cpp;


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

        // convert js parameter to cpp: f (Qt::WindowFlags)

        Qt::WindowFlags a3_cpp;


        if (a3.isUndefined()) {
            a3_cpp = Qt::WindowFlags();
        }
        else {
            a3_cpp = RJSHelper::js2cpp_Qt_WindowFlags(handler, a3);
        }


        // call function:

        // construct wrapper:


        wrapped = new QLabel_Base(
            handler

            ,
            a1_cpp
            , a2_cpp
            , a3_cpp

        );
        wrappedCreated = true;

        // set handler for wrapped base object:
        //((QLabel_Base*)wrapped)->setHandler(handler);

        // store self to call into JS:
        ((QLabel_Base*)wrapped)->self = handler.getSelf();


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


    }

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

                                 )

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

                                       )


    ) {

        // prepare parameters:

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


        // pointer:
        QWidget*
        a1_cpp;


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

        // convert js parameter to cpp: f (Qt::WindowFlags)

        Qt::WindowFlags a2_cpp;


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


        // call function:

        // construct wrapper:


        wrapped = new QLabel_Base(
            handler

            ,
            a1_cpp
            , a2_cpp

        );
        wrappedCreated = true;

        // set handler for wrapped base object:
        //((QLabel_Base*)wrapped)->setHandler(handler);

        // store self to call into JS:
        ((QLabel_Base*)wrapped)->self = handler.getSelf();


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


    }

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

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


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

}

#if QT_DEPRECATED_SINCE(6,6)

#endif

#ifndef QT_NO_PICTURE

#if QT_DEPRECATED_SINCE(6,6)

#endif

#endif

#if QT_CONFIG(movie)

#endif

#ifndef QT_NO_SHORTCUT

#endif

#ifndef QT_NO_PICTURE

#endif

#if QT_CONFIG(movie)

#endif

#ifndef QT_NO_CONTEXTMENU

#endif

#if QT_CONFIG(movie)

#endif

#ifndef QT_NO_SHORTCUT

#endif


// non-static functions:

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setObjectName
// Source: QObject
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setObjectName(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: isWindowType
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: signalsBlocked
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: blockSignals
// Source: QObject
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: findChild
// Source: QObject
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: children
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: installEventFilter
// Source: QObject
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->installEventFilter(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->removeEventFilter(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->dumpObjectTree(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->dumpObjectInfo(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: property
// Source: QObject
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: dynamicPropertyNames
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: parent
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: deleteLater
// Source: QObject
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->deleteLater(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: createWinId
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->createWinId(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: isModal
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: windowModality
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setWindowModality
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setWindowModality(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: isEnabledTo
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setEnabled
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setEnabled(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setDisabled(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setWindowModified(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: geometry
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: normalGeometry
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: x
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

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

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: frameSize
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: size
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: width
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: height
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: rect
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: childrenRect
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: childrenRegion
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: minimumSize
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: maximumSize
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: minimumWidth
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: minimumHeight
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: maximumWidth
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: maximumHeight
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setMinimumSize
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->setMinimumSize(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->setMaximumSize(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setMinimumWidth(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setMinimumHeight(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setMaximumWidth(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setMaximumHeight(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setSizeIncrement
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->setSizeIncrement(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setBaseSize
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->setBaseSize(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->setFixedSize(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setFixedWidth(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setFixedHeight(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* 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: QLabel
// Function: mapFromGlobal
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* 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: QLabel
// Function: mapToParent
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: mapFromParent
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: mapTo
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: mapFrom
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* 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: QLabel
// Function: window
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: nativeParentWidget
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: topLevelWidget
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: palette
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setPalette
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setPalette(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setBackgroundRole
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setBackgroundRole(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: backgroundRole
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setForegroundRole
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setForegroundRole(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: foregroundRole
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: font
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setFont
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setFont(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: fontInfo
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: cursor
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setCursor
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setCursor(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: unsetCursor
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->unsetCursor(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setMouseTracking
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setMouseTracking(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: hasMouseTracking
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: underMouse
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setTabletTracking
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setTabletTracking(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: hasTabletTracking
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setMask
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->setMask(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: mask
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: clearMask
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->clearMask(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: grab
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: grabGesture
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: ungrabGesture
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->ungrabGesture(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setWindowTitle
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setWindowTitle(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setStyleSheet
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setStyleSheet(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: styleSheet
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: windowTitle
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setWindowIcon
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setWindowIcon(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: windowIcon
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setWindowIconText
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setWindowIconText(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: windowIconText
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setWindowRole
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setWindowRole(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: windowRole
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setWindowFilePath
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setWindowFilePath(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: windowFilePath
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setWindowOpacity
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setWindowOpacity(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: windowOpacity
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: isWindowModified
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setToolTip
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setToolTip(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setToolTipDuration
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setToolTipDuration(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: toolTipDuration
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setStatusTip
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setStatusTip(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setWhatsThis
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setWhatsThis(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: accessibleName
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setAccessibleName
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setAccessibleName(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: accessibleDescription
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setAccessibleDescription
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setAccessibleDescription(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setLayoutDirection
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setLayoutDirection(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: layoutDirection
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: unsetLayoutDirection
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->unsetLayoutDirection(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setLocale
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setLocale(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: locale
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: unsetLocale
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->unsetLocale(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: isRightToLeft
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: isLeftToRight
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: isActiveWindow
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: activateWindow
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->activateWindow(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: clearFocus
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->clearFocus(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setFocus
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->setFocus(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: focusPolicy
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setFocusPolicy
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setFocusPolicy(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: hasFocus
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setFocusProxy
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setFocusProxy(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: focusProxy
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: contextMenuPolicy
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setContextMenuPolicy
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setContextMenuPolicy(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: grabMouse
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->grabMouse(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: releaseMouse
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->releaseMouse(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: grabKeyboard
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->grabKeyboard(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: releaseKeyboard
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->releaseKeyboard(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: grabShortcut
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: releaseShortcut
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->releaseShortcut(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setShortcutEnabled
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setShortcutAutoRepeat
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: updatesEnabled
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setUpdatesEnabled
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setUpdatesEnabled(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: update
// Source: QWidget
// Static: false
// Parameters: 4
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::update
(

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

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

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

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

        w->update(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: repaint
// Source: QWidget
// Static: false
// Parameters: 4
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->repaint(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setVisible
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setVisible(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setHidden(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: show
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->show(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: hide
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->hide(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: showMinimized
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->showMinimized(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: showMaximized
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->showMaximized(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: showFullScreen
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->showFullScreen(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: showNormal
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->showNormal(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: close
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: raise
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->raise(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: lower
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->lower(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: stackUnder
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->stackUnder(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: move
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->move(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: resize
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->resize(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setGeometry
// Source: QWidget
// Static: false
// Parameters: 4
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->setGeometry(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: saveGeometry
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: restoreGeometry
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: adjustSize
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->adjustSize(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: isVisible
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: isVisibleTo
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: isHidden
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: isMinimized
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: isMaximized
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: isFullScreen
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: windowState
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setWindowState
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setWindowState(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: overrideWindowState
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->overrideWindowState(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: sizePolicy
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setSizePolicy
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->setSizePolicy(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: hasHeightForWidth
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: visibleRegion
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setContentsMargins
// Source: QWidget
// Static: false
// Parameters: 4
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->setContentsMargins(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: contentsMargins
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: contentsRect
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: layout
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setLayout
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setLayout(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: updateGeometry
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->updateGeometry(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setParent
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->setParent(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: scroll
// Source: QWidget
// Static: false
// Parameters: 3
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* 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: QLabel
// Function: focusWidget
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: nextInFocusChain
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: previousInFocusChain
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: acceptDrops
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setAcceptDrops
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setAcceptDrops(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: addAction
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->addAction(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: addActions
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* w = getWrapped();

        w->addActions(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: insertActions
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* 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: QLabel
// Function: insertAction
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: removeAction
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->removeAction(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: actions
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: parentWidget
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setWindowFlags
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setWindowFlags(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: windowFlags
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setWindowFlag
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: overrideWindowFlags
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->overrideWindowFlags(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: windowType
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: childAt
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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:
        QLabel* 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: QLabel
// Function: setAttribute
// Source: QWidget
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: testAttribute
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: ensurePolished
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->ensurePolished(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: isAncestorOf
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: autoFillBackground
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setAutoFillBackground
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setAutoFillBackground(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: customContextMenuRequested
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QLabel_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: QLabel
// Function: inputMethodQuery
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::inputMethodQuery
(

    const QJSValue&
    a1
)

const

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (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:
        QLabel* 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: QLabel
// Function: inputMethodHints
// Source: QWidget
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setInputMethodHints
// Source: QWidget
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setInputMethodHints(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: frameStyle
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setFrameStyle
// Source: QFrame
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setFrameStyle(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: frameWidth
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: frameShape
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setFrameShape
// Source: QFrame
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setFrameShape(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: frameShadow
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setFrameShadow
// Source: QFrame
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setFrameShadow(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: lineWidth
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setLineWidth
// Source: QFrame
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setLineWidth(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: midLineWidth
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setMidLineWidth
// Source: QFrame
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setMidLineWidth(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: frameRect
// Source: QFrame
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: setFrameRect
// Source: QFrame
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setFrameRect(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_Wrapper::text
(

)

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

            w->text(

            );

        //setRecFlag(false);

        // return type: QString

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

               );

    }

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

}

#if QT_DEPRECATED_SINCE(6,6)

// Class: QLabel
// Function: pixmap
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::pixmap
(

    const QJSValue&
    a1
)

const

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (Qt::ReturnByValueConstant)

        Qt::ReturnByValueConstant a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_ReturnByValueConstant(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:
        QLabel* w = getWrapped();
        QPixmap res =

            w->pixmap(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QPixmap

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

               );

    }

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->pixmap(

            );

        //setRecFlag(false);

        // return type: QPixmap

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

               );

    }

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

}

#endif

#ifndef QT_NO_PICTURE

#if QT_DEPRECATED_SINCE(6,6)

// Class: QLabel
// Function: picture
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::picture
(

    const QJSValue&
    a1
)

const

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (Qt::ReturnByValueConstant)

        Qt::ReturnByValueConstant a1_cpp;

        a1_cpp = RJSHelper::js2cpp_Qt_ReturnByValueConstant(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:
        QLabel* w = getWrapped();
        QPicture res =

            w->picture(
                a1_cpp

            );

        //setRecFlag(false);

        // return type: QPicture

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

               );

    }

    {


        // call function:

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


        //setRecFlag(true);

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

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

            w->picture(

            );

        //setRecFlag(false);

        // return type: QPicture

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

               );

    }

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

}

#endif

#endif

#if QT_CONFIG(movie)

#endif

// Class: QLabel
// Function: textFormat
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::textFormat
(

)

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

            w->textFormat(

            );

        //setRecFlag(false);

        // return type: Qt::TextFormat

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

               );

    }

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

}

// Class: QLabel
// Function: setTextFormat
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::setTextFormat
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (Qt::TextFormat)

        Qt::TextFormat a1_cpp;

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

        w->setTextFormat(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: alignment
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::alignment
(

)

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

            w->alignment(

            );

        //setRecFlag(false);

        // return type: Qt::Alignment

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

               );

    }

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

}

// Class: QLabel
// Function: setAlignment
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::setAlignment
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        w->setAlignment(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setWordWrap
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->setWordWrap(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: wordWrap
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: indent
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::indent
(

)

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

            w->indent(

            );

        //setRecFlag(false);

        // return type: int

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

               );

    }

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

}

// Class: QLabel
// Function: setIndent
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::setIndent
(

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

        w->setIndent(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: margin
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::margin
(

)

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

            w->margin(

            );

        //setRecFlag(false);

        // return type: int

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

               );

    }

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

}

// Class: QLabel
// Function: setMargin
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::setMargin
(

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

        w->setMargin(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: hasScaledContents
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::hasScaledContents
(

)

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

            w->hasScaledContents(

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

// Class: QLabel
// Function: setScaledContents
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::setScaledContents
(

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

        w->setScaledContents(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

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

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: minimumSizeHint
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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();

}

#ifndef QT_NO_SHORTCUT

// Class: QLabel
// Function: setBuddy
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::setBuddy
(

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

        w->setBuddy(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: buddy
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::buddy
(

)

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

            w->buddy(

            );

        //setRecFlag(false);

        // return type: QWidget*

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

               );

    }

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

}

#endif

// Class: QLabel
// Function: heightForWidth
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* 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: QLabel
// Function: openExternalLinks
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::openExternalLinks
(

)

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

            w->openExternalLinks(

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

// Class: QLabel
// Function: setOpenExternalLinks
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::setOpenExternalLinks
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        w->setOpenExternalLinks(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setTextInteractionFlags
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::setTextInteractionFlags
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

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

        Qt::TextInteractionFlags a1_cpp;

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

        w->setTextInteractionFlags(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: textInteractionFlags
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::textInteractionFlags
(

)

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

            w->textInteractionFlags(

            );

        //setRecFlag(false);

        // return type: Qt::TextInteractionFlags

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

               );

    }

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

}

// Class: QLabel
// Function: setSelection
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::setSelection
(

    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:  (int)

        int a1_cpp;

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

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

        w->setSelection(
            a1_cpp
            , a2_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: hasSelectedText
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::hasSelectedText
(

)

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

            w->hasSelectedText(

            );

        //setRecFlag(false);

        // return type: bool

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

               );

    }

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

}

// Class: QLabel
// Function: selectedText
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::selectedText
(

)

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

            w->selectedText(

            );

        //setRecFlag(false);

        // return type: QString

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

               );

    }

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

}

// Class: QLabel
// Function: selectionStart
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::selectionStart
(

)

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

            w->selectionStart(

            );

        //setRecFlag(false);

        // return type: int

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

               );

    }

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

}

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

QJSValue
QLabel_Wrapper::setText
(

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

        w->setText(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: setPixmap
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::setPixmap
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QPixmap)

        QPixmap a1_cpp;

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

        w->setPixmap(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

#ifndef QT_NO_PICTURE

// Class: QLabel
// Function: setPicture
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::setPicture
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QPicture)

        QPicture a1_cpp;

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

        w->setPicture(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

#endif

#if QT_CONFIG(movie)

#endif

// Class: QLabel
// Function: setNum
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::setNum
(

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

        w->setNum(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (double)

        double a1_cpp;

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

        w->setNum(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: clear
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QLabel_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:
        QLabel* w = getWrapped();

        w->clear(

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: linkActivated
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QLabel_Wrapper::linkActivatedEmitter(
    const QString& link
) {
    // convert cpp parameters to js:

    // parameter: link (QString)



    QJSValue a1_js = RJSHelper::cpp2js_QString(
                         handler,
                         link
                     );


    emit linkActivated(
        a1_js
    );
}

// Class: QLabel
// Function: linkHovered
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

// signal emitter: called when signal is emitted from wrapped object:
void
QLabel_Wrapper::linkHoveredEmitter(
    const QString& link
) {
    // convert cpp parameters to js:

    // parameter: link (QString)



    QJSValue a1_js = RJSHelper::cpp2js_QString(
                         handler,
                         link
                     );


    emit linkHovered(
        a1_js
    );
}

// Class: QLabel
// Function: paintEvent
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::
// function is protected, this function can be called from JS implementation to call implementation of super class:
paintEventSuper

(

    const QJSValue&
    a1
)

{

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

                                     )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QPaintEvent)


        // pointer:
        QPaintEvent*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QPaintEvent_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 QLabel_Base class as
        // function has postfix inheritable class, overridable function):
        QLabel_Base* wb = getWrappedBase();
        if (wb==nullptr) {
            qWarning() << "QLabel::paintEvent: using base but wrapper is not of type of base class";
            handler.trace();
            return QJSValue();
        }


        wb->paintEventPublic(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

// Class: QLabel
// Function: mouseMoveEvent
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QLabel_Wrapper::
// function is protected, this function can be called from JS implementation to call implementation of super class:
mouseMoveEventSuper

(

    const QJSValue&
    a1
)

{

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

                                     )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: ev (QMouseEvent)


        // pointer:
        QMouseEvent*
        a1_cpp;

        a1_cpp = RJSHelper::js2cpp_QMouseEvent_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 QLabel_Base class as
        // function has postfix inheritable class, overridable function):
        QLabel_Base* wb = getWrappedBase();
        if (wb==nullptr) {
            qWarning() << "QLabel::mouseMoveEvent: using base but wrapper is not of type of base class";
            handler.trace();
            return QJSValue();
        }


        wb->mouseMoveEventPublic(
            a1_cpp

        );

        //setRecFlag(false);

        return QJSValue();

    }

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

}

#ifndef QT_NO_CONTEXTMENU

#endif

#if QT_CONFIG(movie)

#endif

#ifndef QT_NO_SHORTCUT

#endif


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



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

