
// Auto generated

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

#include "qimage_wrapper.h"


// list of registered base casters for this wrapper class:
QList<RJSBasecaster_QImage*> QImage_Wrapper::basecasters_QImage;

// static functions implementation in singleton wrapper:

// Class: QImage
// Function: devicePixelRatioFScale
// Source: QPaintDevice
// Static: true
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_WrapperSingleton::devicePixelRatioFScale
(

)

{

    {


        // call function:

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

            // call static member function:
            QPaintDevice::devicePixelRatioFScale(

            );

        // return type: qreal

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

               );

    }

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

}

#ifndef Q_QDOC

#endif

#ifndef QT_NO_IMAGEFORMAT_XPM

#endif

#ifndef QT_NO_IMAGE_HEURISTIC_MASK

#endif

// Class: QImage
// Function: trueMatrix
// Source:
// Static: true
// Parameters: 3
// preceding Parameters: -1

QJSValue
QImage_WrapperSingleton::trueMatrix
(

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

{

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

        && RJSHelper::is_int(handler, a2
                            )

        && RJSHelper::is_int(handler, a3
                            )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QTransform)

        QTransform a1_cpp;

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

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

        int a2_cpp;

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

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

        int a3_cpp;

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


        // call function:

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

            // call static member function:
            QImage::trueMatrix(
                a1_cpp
                , a2_cpp
                , a3_cpp

            );

        // return type: QTransform

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

               );

    }

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

}

#if defined(Q_OS_DARWIN)||defined(Q_QDOC)

#endif

#if defined(Q_OS_WIN)||defined(Q_QDOC)

#endif

void QImage_Wrapper::init(RJSApi& handler) {

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


    QJSEngine* engine = handler.getEngine();


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

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



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



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

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

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

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

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

*/


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

    // signal forwarding:
    initConnections();
}


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

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

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


    if (wrappedCreated) {

        // delete wrapped object (copyable, JS ownership)
        //qDebug() << "deleting instance of QImage";
        delete wrapped;

    }

}

// initialization of signal forwarding

void QImage_Wrapper::initConnections() {

    //setObjectName("QImage_Wrapper");

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


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


    if (hasWrapped()) {

        // set up signal forwarding:

    }
}


// constructors:

#ifndef Q_QDOC

#endif

// Class: QImage
// Function:
// Source:
// Static: false
// Parameters: 3
// preceding Parameters: -1
QImage_Wrapper::QImage_Wrapper

(

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

    : RJSWrapperObj(*(RJSApi*)h)

{

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

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

        && RJSHelper::is_int(handler, a2
                            )

        && RJSHelper::is_QImage_Format(handler, a3
                                      )


    ) {

        // prepare parameters:

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

        int a1_cpp;

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

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

        int a2_cpp;

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

        // convert js parameter to cpp: format (QImage::Format)

        QImage::Format a3_cpp;

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


        // call function:

        // construct wrapper:


        wrapped = new QImage(
            a1_cpp
            , a2_cpp
            , a3_cpp

        );
        wrappedCreated = true;


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


    }

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

        && RJSHelper::is_QImage_Format(handler, a2
                                      )


    ) {

        // prepare parameters:

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

        QSize a1_cpp;

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

        // convert js parameter to cpp: format (QImage::Format)

        QImage::Format a2_cpp;

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


        // call function:

        // construct wrapper:


        wrapped = new QImage(
            a1_cpp
            , a2_cpp

        );
        wrappedCreated = true;


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


    }

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

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

                                 )


    ) {

        // prepare parameters:

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

        QString a1_cpp;

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

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


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


        // call function:

        // construct wrapper:


        wrapped = new QImage(
            a1_cpp
            , a2_cpp

        );
        wrappedCreated = true;


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


    }

    {


        // call function:

        // construct wrapper:


        wrapped = new QImage(

        );
        wrappedCreated = true;


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


    }

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

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


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

}

#ifndef QT_NO_IMAGEFORMAT_XPM

#endif

#ifndef QT_NO_IMAGE_HEURISTIC_MASK

#endif

#if defined(Q_OS_DARWIN)||defined(Q_QDOC)

#endif

#if defined(Q_OS_WIN)||defined(Q_QDOC)

#endif


// non-static functions:

// Class: QImage
// Function: paintingActive
// Source: QPaintDevice
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::paintingActive
(

)

const

{

    {


        // call function:

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


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

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

            w->paintingActive(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QImage
// Function: widthMM
// Source: QPaintDevice
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::widthMM
(

)

const

{

    {


        // call function:

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


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

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

            w->widthMM(

            );

        // return type: int

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

               );

    }

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

}

// Class: QImage
// Function: heightMM
// Source: QPaintDevice
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::heightMM
(

)

const

{

    {


        // call function:

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


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

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

            w->heightMM(

            );

        // return type: int

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

               );

    }

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

}

// Class: QImage
// Function: logicalDpiX
// Source: QPaintDevice
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::logicalDpiX
(

)

const

{

    {


        // call function:

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


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

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

            w->logicalDpiX(

            );

        // return type: int

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

               );

    }

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

}

// Class: QImage
// Function: logicalDpiY
// Source: QPaintDevice
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::logicalDpiY
(

)

const

{

    {


        // call function:

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


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

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

            w->logicalDpiY(

            );

        // return type: int

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

               );

    }

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

}

// Class: QImage
// Function: physicalDpiX
// Source: QPaintDevice
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::physicalDpiX
(

)

const

{

    {


        // call function:

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


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

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

            w->physicalDpiX(

            );

        // return type: int

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

               );

    }

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

}

// Class: QImage
// Function: physicalDpiY
// Source: QPaintDevice
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::physicalDpiY
(

)

const

{

    {


        // call function:

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


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

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

            w->physicalDpiY(

            );

        // return type: int

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

               );

    }

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

}

// Class: QImage
// Function: devicePixelRatioF
// Source: QPaintDevice
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::devicePixelRatioF
(

)

const

{

    {


        // call function:

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


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

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

            w->devicePixelRatioF(

            );

        // return type: qreal

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

               );

    }

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

}

#ifndef Q_QDOC

#endif

#ifndef QT_NO_IMAGEFORMAT_XPM

#endif

// Class: QImage
// Function: swap
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QImage_Wrapper::swap
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: other (QImage)

        QImage a1_cpp;

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


        // call function:

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


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

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

        w->swap(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: isNull
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::isNull
(

)

const

{

    {


        // call function:

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


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

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

            w->isNull(

            );

        // return type: bool

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

               );

    }

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

}

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

QJSValue
QImage_Wrapper::devType
(

)

const

{

    {


        // call function:

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


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

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

            w->devType(

            );

        // 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: QImage
// Function: detach
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::detach
(

)

{

    {


        // call function:

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


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

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

        w->detach(

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: isDetached
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::isDetached
(

)

const

{

    {


        // call function:

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


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

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

            w->isDetached(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QImage
// Function: copy
// Source:
// Static: false
// Parameters: 4
// preceding Parameters: -1

QJSValue
QImage_Wrapper::copy
(

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

const

{

    // 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();
        }


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

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

            w->copy(
                a1_cpp
                , a2_cpp
                , a3_cpp
                , a4_cpp

            );

        // return type: QImage

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

               );

    }

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

                           )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: rect (QRect)

        QRect a1_cpp;


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


        // call function:

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


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

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

            w->copy(
                a1_cpp

            );

        // return type: QImage

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

               );

    }

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

}

// Class: QImage
// Function: format
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::format
(

)

const

{

    {


        // call function:

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


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

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

            w->format(

            );

        // return type: QImage::Format

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

               );

    }

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

}

// Class: QImage
// Function: convertToFormat
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QImage_Wrapper::convertToFormat
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

const

{

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

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

                                                )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: f (QImage::Format)

        QImage::Format a1_cpp;

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

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

        Qt::ImageConversionFlags a2_cpp;


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


        // call function:

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


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

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

            w->convertToFormat(
                a1_cpp
                , a2_cpp

            );

        // return type: QImage

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

               );

    }

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

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

                                                )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: f (QImage::Format)

        QImage::Format a1_cpp;

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

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

        Qt::ImageConversionFlags a2_cpp;


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


        // call function:

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


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

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

            w->convertToFormat(
                a1_cpp
                , a2_cpp

            );

        // return type: QImage

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

               );

    }

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

}

// Class: QImage
// Function: reinterpretAsFormat
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QImage_Wrapper::reinterpretAsFormat
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: f (QImage::Format)

        QImage::Format a1_cpp;

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


        // call function:

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


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

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

            w->reinterpretAsFormat(
                a1_cpp

            );

        // return type: bool

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

               );

    }

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

}

// Class: QImage
// Function: convertedTo
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QImage_Wrapper::convertedTo
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

const

{

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

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

                                                )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: f (QImage::Format)

        QImage::Format a1_cpp;

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

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

        Qt::ImageConversionFlags a2_cpp;


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


        // call function:

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


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

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

            w->convertedTo(
                a1_cpp
                , a2_cpp

            );

        // return type: QImage

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

               );

    }

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

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

                                                )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: f (QImage::Format)

        QImage::Format a1_cpp;

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

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

        Qt::ImageConversionFlags a2_cpp;


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


        // call function:

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


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

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

            w->convertedTo(
                a1_cpp
                , a2_cpp

            );

        // return type: QImage

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

               );

    }

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

}

// Class: QImage
// Function: convertTo
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QImage_Wrapper::convertTo
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                                )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: f (QImage::Format)

        QImage::Format a1_cpp;

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

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

        Qt::ImageConversionFlags a2_cpp;


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


        // call function:

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


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

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

        w->convertTo(
            a1_cpp
            , a2_cpp

        );

        return QJSValue();

    }

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

}

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

QJSValue
QImage_Wrapper::width
(

)

const

{

    {


        // call function:

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


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

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

            w->width(

            );

        // 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: QImage
// Function: height
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::height
(

)

const

{

    {


        // call function:

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


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

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

            w->height(

            );

        // 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: QImage
// Function: size
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::size
(

)

const

{

    {


        // call function:

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


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

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

            w->size(

            );

        // 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: QImage
// Function: rect
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::rect
(

)

const

{

    {


        // call function:

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


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

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

            w->rect(

            );

        // 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: QImage
// Function: depth
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::depth
(

)

const

{

    {


        // call function:

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


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

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

            w->depth(

            );

        // return type: int

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

               );

    }

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

}

// Class: QImage
// Function: colorCount
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::colorCount
(

)

const

{

    {


        // call function:

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


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

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

            w->colorCount(

            );

        // return type: int

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

               );

    }

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

}

// Class: QImage
// Function: bitPlaneCount
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::bitPlaneCount
(

)

const

{

    {


        // call function:

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


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

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

            w->bitPlaneCount(

            );

        // return type: int

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

               );

    }

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

}

// Class: QImage
// Function: setColorCount
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QImage_Wrapper::setColorCount
(

    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();
        }


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

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

        w->setColorCount(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: allGray
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::allGray
(

)

const

{

    {


        // call function:

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


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

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

            w->allGray(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QImage
// Function: isGrayscale
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::isGrayscale
(

)

const

{

    {


        // call function:

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


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

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

            w->isGrayscale(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QImage
// Function: sizeInBytes
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::sizeInBytes
(

)

const

{

    {


        // call function:

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


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

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

            w->sizeInBytes(

            );

        // return type: qsizetype

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

               );

    }

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

}

// Class: QImage
// Function: bytesPerLine
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::bytesPerLine
(

)

const

{

    {


        // call function:

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


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

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

            w->bytesPerLine(

            );

        // return type: qsizetype

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

               );

    }

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

}

// Class: QImage
// Function: valid
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QImage_Wrapper::valid
(

    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();
        }


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

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

            w->valid(
                a1_cpp
                , a2_cpp

            );

        // return type: bool

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

               );

    }

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


    ) {

        // prepare parameters:

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

        QPoint a1_cpp;

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


        // call function:

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


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

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

            w->valid(
                a1_cpp

            );

        // return type: bool

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

               );

    }

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

}

// Class: QImage
// Function: pixelIndex
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QImage_Wrapper::pixelIndex
(

    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();
        }


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

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

            w->pixelIndex(
                a1_cpp
                , a2_cpp

            );

        // return type: int

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

               );

    }

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


    ) {

        // prepare parameters:

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

        QPoint a1_cpp;

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


        // call function:

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


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

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

            w->pixelIndex(
                a1_cpp

            );

        // return type: int

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

               );

    }

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

}

// Class: QImage
// Function: setPixel
// Source:
// Static: false
// Parameters: 3
// preceding Parameters: -1

QJSValue
QImage_Wrapper::setPixel
(

    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_uint(handler, a3
                             )


    ) {

        // 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: index_or_rgb (uint)

        uint a3_cpp;

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


        // call function:

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


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

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

        w->setPixel(
            a1_cpp
            , a2_cpp
            , a3_cpp

        );

        return QJSValue();

    }

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

        && RJSHelper::is_uint(handler, a2
                             )


    ) {

        // prepare parameters:

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

        QPoint a1_cpp;

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

        // convert js parameter to cpp: index_or_rgb (uint)

        uint a2_cpp;

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


        // call function:

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


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

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

        w->setPixel(
            a1_cpp
            , a2_cpp

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: pixelColor
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QImage_Wrapper::pixelColor
(

    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();
        }


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

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

            w->pixelColor(
                a1_cpp
                , a2_cpp

            );

        // return type: QColor

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

               );

    }

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


    ) {

        // prepare parameters:

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

        QPoint a1_cpp;

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


        // call function:

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


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

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

            w->pixelColor(
                a1_cpp

            );

        // return type: QColor

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

               );

    }

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

}

// Class: QImage
// Function: setPixelColor
// Source:
// Static: false
// Parameters: 3
// preceding Parameters: -1

QJSValue
QImage_Wrapper::setPixelColor
(

    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_QColor(handler, a3
                               )


    ) {

        // 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: c (QColor)

        QColor a3_cpp;

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


        // call function:

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


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

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

        w->setPixelColor(
            a1_cpp
            , a2_cpp
            , a3_cpp

        );

        return QJSValue();

    }

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

        && RJSHelper::is_QColor(handler, a2
                               )


    ) {

        // prepare parameters:

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

        QPoint a1_cpp;

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

        // convert js parameter to cpp: c (QColor)

        QColor a2_cpp;

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


        // call function:

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


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

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

        w->setPixelColor(
            a1_cpp
            , a2_cpp

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: devicePixelRatio
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::devicePixelRatio
(

)

const

{

    {


        // call function:

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


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

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

            w->devicePixelRatio(

            );

        // return type: qreal

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

               );

    }

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

}

// Class: QImage
// Function: setDevicePixelRatio
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QImage_Wrapper::setDevicePixelRatio
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: scaleFactor (qreal)

        qreal a1_cpp;

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


        // call function:

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


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

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

        w->setDevicePixelRatio(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: deviceIndependentSize
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::deviceIndependentSize
(

)

const

{

    {


        // call function:

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


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

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

            w->deviceIndependentSize(

            );

        // return type: QSizeF

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

               );

    }

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

}

// Class: QImage
// Function: fill
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QImage_Wrapper::fill
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: pixel (uint)

        uint a1_cpp;

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


        // call function:

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


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

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

        w->fill(
            a1_cpp

        );

        return QJSValue();

    }

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: color (QColor)

        QColor a1_cpp;

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


        // call function:

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


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

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

        w->fill(
            a1_cpp

        );

        return QJSValue();

    }

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: color (Qt::GlobalColor)

        Qt::GlobalColor a1_cpp;

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


        // call function:

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


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

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

        w->fill(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: hasAlphaChannel
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::hasAlphaChannel
(

)

const

{

    {


        // call function:

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


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

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

            w->hasAlphaChannel(

            );

        // return type: bool

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

               );

    }

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

}

// Class: QImage
// Function: setAlphaChannel
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QImage_Wrapper::setAlphaChannel
(

    const QJSValue&
    a1
)

{

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


    ) {

        // prepare parameters:

        // convert js parameter to cpp: alphaChannel (QImage)

        QImage a1_cpp;

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


        // call function:

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


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

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

        w->setAlphaChannel(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: createAlphaMask
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QImage_Wrapper::createAlphaMask
(

    const QJSValue&
    a1
)

const

{

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

                                             )


    ) {

        // prepare parameters:

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

        Qt::ImageConversionFlags a1_cpp;


        if (a1.isUndefined()) {
            a1_cpp = Qt::AutoColor;
        }
        else {
            a1_cpp = RJSHelper::js2cpp_Qt_ImageConversionFlags(handler, a1);
        }


        // call function:

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


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

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

            w->createAlphaMask(
                a1_cpp

            );

        // return type: QImage

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

               );

    }

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

}

#ifndef QT_NO_IMAGE_HEURISTIC_MASK

// Class: QImage
// Function: createHeuristicMask
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QImage_Wrapper::createHeuristicMask
(

    const QJSValue&
    a1
)

const

{

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

                          )


    ) {

        // prepare parameters:

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

        bool a1_cpp;


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


        // call function:

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


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

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

            w->createHeuristicMask(
                a1_cpp

            );

        // return type: QImage

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

               );

    }

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

}

#endif

// Class: QImage
// Function: scaled
// Source:
// Static: false
// Parameters: 4
// preceding Parameters: -1

QJSValue
QImage_Wrapper::scaled
(

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

const

{

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

        && RJSHelper::is_int(handler, a2
                            )

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

                                           )

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

                                              )


    ) {

        // 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);

        // convert js parameter to cpp: aspectMode (Qt::AspectRatioMode)

        Qt::AspectRatioMode a3_cpp;


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

        // convert js parameter to cpp: mode (Qt::TransformationMode)

        Qt::TransformationMode a4_cpp;


        if (a4.isUndefined()) {
            a4_cpp = Qt::FastTransformation;
        }
        else {
            a4_cpp = RJSHelper::js2cpp_Qt_TransformationMode(handler, a4);
        }


        // call function:

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


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

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

            w->scaled(
                a1_cpp
                , a2_cpp
                , a3_cpp
                , a4_cpp

            );

        // return type: QImage

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

               );

    }

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

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

                                           )

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

                                              )


    ) {

        // prepare parameters:

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

        QSize a1_cpp;

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

        // convert js parameter to cpp: aspectMode (Qt::AspectRatioMode)

        Qt::AspectRatioMode a2_cpp;


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

        // convert js parameter to cpp: mode (Qt::TransformationMode)

        Qt::TransformationMode a3_cpp;


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


        // call function:

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


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

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

            w->scaled(
                a1_cpp
                , a2_cpp
                , a3_cpp

            );

        // return type: QImage

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

               );

    }

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

}

// Class: QImage
// Function: scaledToWidth
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QImage_Wrapper::scaledToWidth
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

const

{

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

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

                                              )


    ) {

        // prepare parameters:

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

        int a1_cpp;

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

        // convert js parameter to cpp: mode (Qt::TransformationMode)

        Qt::TransformationMode a2_cpp;


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


        // call function:

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


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

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

            w->scaledToWidth(
                a1_cpp
                , a2_cpp

            );

        // return type: QImage

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

               );

    }

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

}

// Class: QImage
// Function: scaledToHeight
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QImage_Wrapper::scaledToHeight
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

const

{

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

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

                                              )


    ) {

        // prepare parameters:

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

        int a1_cpp;

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

        // convert js parameter to cpp: mode (Qt::TransformationMode)

        Qt::TransformationMode a2_cpp;


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


        // call function:

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


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

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

            w->scaledToHeight(
                a1_cpp
                , a2_cpp

            );

        // return type: QImage

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

               );

    }

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

}

// Class: QImage
// Function: transformed
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QImage_Wrapper::transformed
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

const

{

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

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

                                              )


    ) {

        // prepare parameters:

        // convert js parameter to cpp: matrix (QTransform)

        QTransform a1_cpp;

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

        // convert js parameter to cpp: mode (Qt::TransformationMode)

        Qt::TransformationMode a2_cpp;


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


        // call function:

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


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

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

            w->transformed(
                a1_cpp
                , a2_cpp

            );

        // return type: QImage

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

               );

    }

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

}

// Class: QImage
// Function: mirrored
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QImage_Wrapper::mirrored
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

const

{

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

                          )

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

                             )


    ) {

        // prepare parameters:

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

        bool a1_cpp;


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

        // convert js parameter to cpp: vertically (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();
        }


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

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

            w->mirrored(
                a1_cpp
                , a2_cpp

            );

        // return type: QImage

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

               );

    }

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

                          )

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

                             )


    ) {

        // prepare parameters:

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

        bool a1_cpp;


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

        // convert js parameter to cpp: vertically (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();
        }


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

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

            w->mirrored(
                a1_cpp
                , a2_cpp

            );

        // return type: QImage

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

               );

    }

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

}

// Class: QImage
// Function: rgbSwapped
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::rgbSwapped
(

)

const

{

    {


        // call function:

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


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

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

            w->rgbSwapped(

            );

        // return type: QImage

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

               );

    }

    {


        // call function:

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


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

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

            w->rgbSwapped(

            );

        // return type: QImage

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

               );

    }

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

}

// Class: QImage
// Function: mirror
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QImage_Wrapper::mirror
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

                          )

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

                             )


    ) {

        // prepare parameters:

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

        bool a1_cpp;


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

        // convert js parameter to cpp: vertically (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();
        }


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

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

        w->mirror(
            a1_cpp
            , a2_cpp

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: rgbSwap
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::rgbSwap
(

)

{

    {


        // call function:

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


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

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

        w->rgbSwap(

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: invertPixels
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QImage_Wrapper::invertPixels
(

    const QJSValue&
    a1
)

{

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

                                       )


    ) {

        // prepare parameters:

        // convert js parameter to cpp:  (QImage::InvertMode)

        QImage::InvertMode a1_cpp;


        if (a1.isUndefined()) {
            a1_cpp = QImage::InvertRgb;
        }
        else {
            a1_cpp = RJSHelper::js2cpp_QImage_InvertMode(handler, a1);
        }


        // call function:

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


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

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

        w->invertPixels(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: load
// Source:
// Static: false
// Parameters: 2
// preceding Parameters: -1

QJSValue
QImage_Wrapper::load
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

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

                                 )


    ) {

        // prepare parameters:

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

        QString a1_cpp;

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

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


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


        // call function:

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


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

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

            w->load(
                a1_cpp
                , a2_cpp

            );

        // return type: bool

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

               );

    }

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

}

// Class: QImage
// Function: save
// Source:
// Static: false
// Parameters: 3
// preceding Parameters: -1

QJSValue
QImage_Wrapper::save
(

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

const

{

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

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

                                 )

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

                            )


    ) {

        // prepare parameters:

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

        QString a1_cpp;

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

        // convert js parameter to cpp: format (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: quality (int)

        int a3_cpp;


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


        // call function:

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


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

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

            w->save(
                a1_cpp
                , a2_cpp
                , a3_cpp

            );

        // return type: bool

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

               );

    }

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

}

// Class: QImage
// Function: cacheKey
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::cacheKey
(

)

const

{

    {


        // call function:

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


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

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

            w->cacheKey(

            );

        // return type: qint64

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

               );

    }

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

}

// Class: QImage
// Function: paintEngine
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::paintEngine
(

)

const

{

    {


        // call function:

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


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

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

            w->paintEngine(

            );

        // return type: QPaintEngine*

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

               );

    }

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

}

// Class: QImage
// Function: dotsPerMeterX
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::dotsPerMeterX
(

)

const

{

    {


        // call function:

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


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

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

            w->dotsPerMeterX(

            );

        // return type: int

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

               );

    }

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

}

// Class: QImage
// Function: dotsPerMeterY
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::dotsPerMeterY
(

)

const

{

    {


        // call function:

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


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

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

            w->dotsPerMeterY(

            );

        // return type: int

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

               );

    }

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

}

// Class: QImage
// Function: setDotsPerMeterX
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QImage_Wrapper::setDotsPerMeterX
(

    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();
        }


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

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

        w->setDotsPerMeterX(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: setDotsPerMeterY
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QImage_Wrapper::setDotsPerMeterY
(

    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();
        }


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

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

        w->setDotsPerMeterY(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: offset
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::offset
(

)

const

{

    {


        // call function:

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


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

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

            w->offset(

            );

        // return type: QPoint

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

               );

    }

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

}

// Class: QImage
// Function: setOffset
// Source:
// Static: false
// Parameters: 1
// preceding Parameters: -1

QJSValue
QImage_Wrapper::setOffset
(

    const QJSValue&
    a1
)

{

    // 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();
        }


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

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

        w->setOffset(
            a1_cpp

        );

        return QJSValue();

    }

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

}

// Class: QImage
// Function: textKeys
// Source:
// Static: false
// Parameters: 0
// preceding Parameters: -1

QJSValue
QImage_Wrapper::textKeys
(

)

const

{

    {


        // call function:

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


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

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

            w->textKeys(

            );

        // return type: QStringList

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

               );

    }

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

}

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

QJSValue
QImage_Wrapper::text
(

    const QJSValue&
    a1
)

const

{

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

                             )


    ) {

        // prepare parameters:

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

        QString a1_cpp;


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


        // call function:

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


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

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

            w->text(
                a1_cpp

            );

        // return type: QString

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

               );

    }

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

}

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

QJSValue
QImage_Wrapper::setText
(

    const QJSValue&
    a1,
    const QJSValue&
    a2
)

{

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

        && RJSHelper::is_QString(handler, a2
                                )


    ) {

        // prepare parameters:

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

        QString a1_cpp;

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

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

        QString a2_cpp;

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


        // call function:

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


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

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

        w->setText(
            a1_cpp
            , a2_cpp

        );

        return QJSValue();

    }

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

}

#if defined(Q_OS_DARWIN)||defined(Q_QDOC)

#endif

#if defined(Q_OS_WIN)||defined(Q_QDOC)

#endif


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



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

