// ***** AUTOGENERATED CODE, DO NOT EDIT *****
            // ***** This class is copyable.
        
        #include "REcmaGraphicsSceneDrawable.h"
        #include "RMetaTypes.h"
        #include "../REcmaHelper.h"

        // forwards declarations mapped to includes
        
            
        // includes for base ecma wrapper classes
         void REcmaGraphicsSceneDrawable::initEcma(QScriptEngine& engine, QScriptValue* proto 
    
    ) 
    
    {

    bool protoCreated = false;
    if(proto == NULL){
        proto = new QScriptValue(engine.newVariant(qVariantFromValue(
                (RGraphicsSceneDrawable*) 0)));
        protoCreated = true;
    }

    

    QScriptValue fun;

    // toString:
    REcmaHelper::registerFunction(&engine, proto, toString, "toString");
    
    // copy:
    REcmaHelper::registerFunction(&engine, proto, copy, "copy");
    

    // destroy:
    REcmaHelper::registerFunction(&engine, proto, destroy, "destroy");
    

    // get class name
    REcmaHelper::registerFunction(&engine, proto, getClassName, "getClassName");
    

    // conversion to all base classes (multiple inheritance):
    REcmaHelper::registerFunction(&engine, proto, getBaseClasses, "getBaseClasses");
    

    // properties:
    

    // methods:
    
            REcmaHelper::registerFunction(&engine, proto, uninit, "uninit");
            
            REcmaHelper::registerFunction(&engine, proto, getType, "getType");
            
            REcmaHelper::registerFunction(&engine, proto, isPainterPath, "isPainterPath");
            
            REcmaHelper::registerFunction(&engine, proto, isText, "isText");
            
            REcmaHelper::registerFunction(&engine, proto, isImage, "isImage");
            
            REcmaHelper::registerFunction(&engine, proto, setMode, "setMode");
            
            REcmaHelper::registerFunction(&engine, proto, getMode, "getMode");
            
            REcmaHelper::registerFunction(&engine, proto, setNoPlot, "setNoPlot");
            
            REcmaHelper::registerFunction(&engine, proto, getNoPlot, "getNoPlot");
            
            REcmaHelper::registerFunction(&engine, proto, setPixelUnit, "setPixelUnit");
            
            REcmaHelper::registerFunction(&engine, proto, getPixelUnit, "getPixelUnit");
            
            REcmaHelper::registerFunction(&engine, proto, setWorkingSet, "setWorkingSet");
            
            REcmaHelper::registerFunction(&engine, proto, isWorkingSet, "isWorkingSet");
            
            REcmaHelper::registerFunction(&engine, proto, getPainterPath, "getPainterPath");
            
            REcmaHelper::registerFunction(&engine, proto, getImage, "getImage");
            
            REcmaHelper::registerFunction(&engine, proto, getText, "getText");
            
            REcmaHelper::registerFunction(&engine, proto, getTransform, "getTransform");
            
            REcmaHelper::registerFunction(&engine, proto, getOffset, "getOffset");
            
            REcmaHelper::registerFunction(&engine, proto, setOffset, "setOffset");
            
            REcmaHelper::registerFunction(&engine, proto, getDocument, "getDocument");
            
            REcmaHelper::registerFunction(&engine, proto, setSelected, "setSelected");
            
            REcmaHelper::registerFunction(&engine, proto, setHighlighted, "setHighlighted");
            
            REcmaHelper::registerFunction(&engine, proto, operator_assign, "operator_assign");
            
        engine.setDefaultPrototype(
            qMetaTypeId<RGraphicsSceneDrawable*>(), *proto);

        
                engine.setDefaultPrototype(qMetaTypeId<
                RGraphicsSceneDrawable
                > (), *proto);
            
    

    QScriptValue ctor = engine.newFunction(createEcma, *proto, 2);
    
    // static methods:
    
            REcmaHelper::registerFunction(&engine, &ctor, createFromPainterPath, "createFromPainterPath");
            
            REcmaHelper::registerFunction(&engine, &ctor, createFromImage, "createFromImage");
            
            REcmaHelper::registerFunction(&engine, &ctor, createFromText, "createFromText");
            
            REcmaHelper::registerFunction(&engine, &ctor, createFromTransform, "createFromTransform");
            
            REcmaHelper::registerFunction(&engine, &ctor, createEndTransform, "createEndTransform");
            

    // static properties:
    

    // enum values:
    

    ctor.setProperty("Invalid",
    QScriptValue(RGraphicsSceneDrawable::Invalid),
    QScriptValue::ReadOnly);


    ctor.setProperty("PainterPath",
    QScriptValue(RGraphicsSceneDrawable::PainterPath),
    QScriptValue::ReadOnly);


    ctor.setProperty("PainterPathRay",
    QScriptValue(RGraphicsSceneDrawable::PainterPathRay),
    QScriptValue::ReadOnly);


    ctor.setProperty("PainterPathXLine",
    QScriptValue(RGraphicsSceneDrawable::PainterPathXLine),
    QScriptValue::ReadOnly);


    ctor.setProperty("Image",
    QScriptValue(RGraphicsSceneDrawable::Image),
    QScriptValue::ReadOnly);


    ctor.setProperty("Text",
    QScriptValue(RGraphicsSceneDrawable::Text),
    QScriptValue::ReadOnly);


    ctor.setProperty("Transform",
    QScriptValue(RGraphicsSceneDrawable::Transform),
    QScriptValue::ReadOnly);


    ctor.setProperty("EndTransform",
    QScriptValue(RGraphicsSceneDrawable::EndTransform),
    QScriptValue::ReadOnly);


    ctor.setProperty("NoMode",
    QScriptValue(RGraphicsSceneDrawable::NoMode),
    QScriptValue::ReadOnly);


    ctor.setProperty("NoPlot",
    QScriptValue(RGraphicsSceneDrawable::NoPlot),
    QScriptValue::ReadOnly);


    ctor.setProperty("PixelUnit",
    QScriptValue(RGraphicsSceneDrawable::PixelUnit),
    QScriptValue::ReadOnly);


    ctor.setProperty("WorkingSet",
    QScriptValue(RGraphicsSceneDrawable::WorkingSet),
    QScriptValue::ReadOnly);


    // enum conversions:
    
    qScriptRegisterMetaType<RGraphicsSceneDrawable::Type>(
        &engine,
        toScriptValueEnumType,
        fromScriptValueEnumType,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RGraphicsSceneDrawable::Mode>(
        &engine,
        toScriptValueEnumMode,
        fromScriptValueEnumMode,
        ctor.property(QString::fromLatin1("prototype"))
    );

        
    // init class:
    engine.globalObject().setProperty("RGraphicsSceneDrawable",
    ctor, QScriptValue::SkipInEnumeration);
    
    if( protoCreated ){
       delete proto;
    }
    
    }
     QScriptValue REcmaGraphicsSceneDrawable::createEcma(QScriptContext* context, QScriptEngine* engine) 
    
    {
    if (context->thisObject().strictlyEquals(
       engine->globalObject())) {
       return REcmaHelper::throwError(
       QString::fromLatin1("RGraphicsSceneDrawable(): Did you forget to construct with 'new'?"),
           context);
    }

    QScriptValue result;
        
            // generate constructor variants:
            
    if( context->argumentCount() ==
        0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ constructor:
    
            // copyable class:
            RGraphicsSceneDrawable
                    cppResult;
                
            result = engine->newVariant(
            context->thisObject(), qVariantFromValue(cppResult));
        
    } else 

    if( context->argumentCount() ==
        1
                && (
                
                        context->argument(
                        0
                        ).isVariant()
                        ||
                    
                        context->argument(
                        0
                        ).isQObject()
                        ||
                    
                        context->argument(
                        0
                        ).isNull()
                ) /* type: RGraphicsSceneDrawable */
            
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RGraphicsSceneDrawable*
                    ap0 =
                    qscriptvalue_cast<
                    RGraphicsSceneDrawable*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RGraphicsSceneDrawable.",
                               context);                    
                    }
                    RGraphicsSceneDrawable 
                    a0 = 
                    *ap0;
                
    // end of arguments

    // call C++ constructor:
    
            // copyable class:
            RGraphicsSceneDrawable
                    cppResult(
                    a0
                    );
                
            result = engine->newVariant(
            context->thisObject(), qVariantFromValue(cppResult));
        
    } else 

    {
       return REcmaHelper::throwError(
       QString::fromLatin1("RGraphicsSceneDrawable(): no matching constructor found."),
           context);
    }
    
    return result;
    }
    

    // conversion functions for base classes:
    

    // returns class name:
     QScriptValue REcmaGraphicsSceneDrawable::getClassName(QScriptContext *context, QScriptEngine *engine) 
        
    {
        return qScriptValueFromValue(engine, QString("RGraphicsSceneDrawable"));
    }
    

    // returns all base classes (in case of multiple inheritance):
     QScriptValue REcmaGraphicsSceneDrawable::getBaseClasses(QScriptContext *context, QScriptEngine *engine) 
        
    {
        QStringList list;
        

        return qScriptValueFromSequence(engine, list);
    }
    

    // properties:
    

    // public methods:
     QScriptValue
        REcmaGraphicsSceneDrawable::createFromPainterPath
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::createFromPainterPath", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::createFromPainterPath";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RPainterPath */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RPainterPath*
                    ap0 =
                    qscriptvalue_cast<
                    RPainterPath*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RPainterPath.",
                               context);                    
                    }
                    RPainterPath 
                    a0 = 
                    *ap0;
                
    // end of arguments

    // call C++ function:
    // return type 'RGraphicsSceneDrawable'
    RGraphicsSceneDrawable cppResult =
        RGraphicsSceneDrawable::
       createFromPainterPath(a0);
        // return type: RGraphicsSceneDrawable
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RPainterPath */
     && (
            context->argument(1).isVariant() || 
            context->argument(1).isQObject() || 
            context->argument(1).isNull()
        ) /* type: RVector */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RPainterPath*
                    ap0 =
                    qscriptvalue_cast<
                    RPainterPath*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RPainterPath.",
                               context);                    
                    }
                    RPainterPath 
                    a0 = 
                    *ap0;
                
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RVector*
                    ap1 =
                    qscriptvalue_cast<
                    RVector*
                        >(
                        context->argument(
                        1
                        )
                    );
                    if (ap1 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 1 is not of type RVector.",
                               context);                    
                    }
                    RVector 
                    a1 = 
                    *ap1;
                
    // end of arguments

    // call C++ function:
    // return type 'RGraphicsSceneDrawable'
    RGraphicsSceneDrawable cppResult =
        RGraphicsSceneDrawable::
       createFromPainterPath(a0
        ,
    a1);
        // return type: RGraphicsSceneDrawable
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.createFromPainterPath().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::createFromPainterPath", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::createFromImage
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::createFromImage", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::createFromImage";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RImageData */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RImageData*
                    ap0 =
                    qscriptvalue_cast<
                    RImageData*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RImageData.",
                               context);                    
                    }
                    RImageData 
                    a0 = 
                    *ap0;
                
    // end of arguments

    // call C++ function:
    // return type 'RGraphicsSceneDrawable'
    RGraphicsSceneDrawable cppResult =
        RGraphicsSceneDrawable::
       createFromImage(a0);
        // return type: RGraphicsSceneDrawable
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RImageData */
     && (
            context->argument(1).isVariant() || 
            context->argument(1).isQObject() || 
            context->argument(1).isNull()
        ) /* type: RVector */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RImageData*
                    ap0 =
                    qscriptvalue_cast<
                    RImageData*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RImageData.",
                               context);                    
                    }
                    RImageData 
                    a0 = 
                    *ap0;
                
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RVector*
                    ap1 =
                    qscriptvalue_cast<
                    RVector*
                        >(
                        context->argument(
                        1
                        )
                    );
                    if (ap1 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 1 is not of type RVector.",
                               context);                    
                    }
                    RVector 
                    a1 = 
                    *ap1;
                
    // end of arguments

    // call C++ function:
    // return type 'RGraphicsSceneDrawable'
    RGraphicsSceneDrawable cppResult =
        RGraphicsSceneDrawable::
       createFromImage(a0
        ,
    a1);
        // return type: RGraphicsSceneDrawable
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.createFromImage().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::createFromImage", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::createFromText
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::createFromText", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::createFromText";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RTextBasedData */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RTextBasedData*
                    ap0 =
                    qscriptvalue_cast<
                    RTextBasedData*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RTextBasedData.",
                               context);                    
                    }
                    RTextBasedData 
                    a0 = 
                    *ap0;
                
    // end of arguments

    // call C++ function:
    // return type 'RGraphicsSceneDrawable'
    RGraphicsSceneDrawable cppResult =
        RGraphicsSceneDrawable::
       createFromText(a0);
        // return type: RGraphicsSceneDrawable
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RTextBasedData */
     && (
            context->argument(1).isVariant() || 
            context->argument(1).isQObject() || 
            context->argument(1).isNull()
        ) /* type: RVector */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RTextBasedData*
                    ap0 =
                    qscriptvalue_cast<
                    RTextBasedData*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RTextBasedData.",
                               context);                    
                    }
                    RTextBasedData 
                    a0 = 
                    *ap0;
                
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RVector*
                    ap1 =
                    qscriptvalue_cast<
                    RVector*
                        >(
                        context->argument(
                        1
                        )
                    );
                    if (ap1 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 1 is not of type RVector.",
                               context);                    
                    }
                    RVector 
                    a1 = 
                    *ap1;
                
    // end of arguments

    // call C++ function:
    // return type 'RGraphicsSceneDrawable'
    RGraphicsSceneDrawable cppResult =
        RGraphicsSceneDrawable::
       createFromText(a0
        ,
    a1);
        // return type: RGraphicsSceneDrawable
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.createFromText().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::createFromText", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::createFromTransform
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::createFromTransform", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::createFromTransform";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RTransform */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RTransform*
                    ap0 =
                    qscriptvalue_cast<
                    RTransform*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RTransform.",
                               context);                    
                    }
                    RTransform 
                    a0 = 
                    *ap0;
                
    // end of arguments

    // call C++ function:
    // return type 'RGraphicsSceneDrawable'
    RGraphicsSceneDrawable cppResult =
        RGraphicsSceneDrawable::
       createFromTransform(a0);
        // return type: RGraphicsSceneDrawable
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RTransform */
     && (
            context->argument(1).isVariant() || 
            context->argument(1).isQObject() || 
            context->argument(1).isNull()
        ) /* type: RVector */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RTransform*
                    ap0 =
                    qscriptvalue_cast<
                    RTransform*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RTransform.",
                               context);                    
                    }
                    RTransform 
                    a0 = 
                    *ap0;
                
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RVector*
                    ap1 =
                    qscriptvalue_cast<
                    RVector*
                        >(
                        context->argument(
                        1
                        )
                    );
                    if (ap1 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 1 is not of type RVector.",
                               context);                    
                    }
                    RVector 
                    a1 = 
                    *ap1;
                
    // end of arguments

    // call C++ function:
    // return type 'RGraphicsSceneDrawable'
    RGraphicsSceneDrawable cppResult =
        RGraphicsSceneDrawable::
       createFromTransform(a0
        ,
    a1);
        // return type: RGraphicsSceneDrawable
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.createFromTransform().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::createFromTransform", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::createEndTransform
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::createEndTransform", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::createEndTransform";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RVector */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RVector*
                    ap0 =
                    qscriptvalue_cast<
                    RVector*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RVector.",
                               context);                    
                    }
                    RVector 
                    a0 = 
                    *ap0;
                
    // end of arguments

    // call C++ function:
    // return type 'RGraphicsSceneDrawable'
    RGraphicsSceneDrawable cppResult =
        RGraphicsSceneDrawable::
       createEndTransform(a0);
        // return type: RGraphicsSceneDrawable
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.createEndTransform().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::createEndTransform", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::uninit
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::uninit", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::uninit";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("uninit", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'void'
    
               self->uninit();
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.uninit().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::uninit", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::getType
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::getType", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::getType";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("getType", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'RGraphicsSceneDrawable::Type'
    RGraphicsSceneDrawable::Type cppResult =
        
               self->getType();
        // return type: RGraphicsSceneDrawable::Type
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.getType().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::getType", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::isPainterPath
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::isPainterPath", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::isPainterPath";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("isPainterPath", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        
               self->isPainterPath();
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.isPainterPath().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::isPainterPath", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::isText
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::isText", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::isText";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("isText", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        
               self->isText();
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.isText().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::isText", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::isImage
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::isImage", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::isImage";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("isImage", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        
               self->isImage();
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.isImage().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::isImage", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::setMode
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::setMode", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::setMode";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("setMode", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RGraphicsSceneDrawable::Mode */
    
    ){
    // prepare arguments:
    
                    // argument is reference
                    RGraphicsSceneDrawable::Mode*
                    ap0 =
                    qscriptvalue_cast<
                    RGraphicsSceneDrawable::Mode*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if( ap0 == NULL ){
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RGraphicsSceneDrawable::Mode*.",
                               context);                    
                    }
                    RGraphicsSceneDrawable::Mode& a0 = *ap0;
                
    // end of arguments

    // call C++ function:
    // return type 'void'
    
               self->setMode(a0);
    } else


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RGraphicsSceneDrawable::Mode */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument is reference
                    RGraphicsSceneDrawable::Mode*
                    ap0 =
                    qscriptvalue_cast<
                    RGraphicsSceneDrawable::Mode*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if( ap0 == NULL ){
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RGraphicsSceneDrawable::Mode*.",
                               context);                    
                    }
                    RGraphicsSceneDrawable::Mode& a0 = *ap0;
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
    // end of arguments

    // call C++ function:
    // return type 'void'
    
               self->setMode(a0
        ,
    a1);
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.setMode().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::setMode", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::getMode
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::getMode", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::getMode";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("getMode", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RGraphicsSceneDrawable::Mode */
    
    ){
    // prepare arguments:
    
                    // argument is reference
                    RGraphicsSceneDrawable::Mode*
                    ap0 =
                    qscriptvalue_cast<
                    RGraphicsSceneDrawable::Mode*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if( ap0 == NULL ){
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RGraphicsSceneDrawable::Mode*.",
                               context);                    
                    }
                    RGraphicsSceneDrawable::Mode& a0 = *ap0;
                
    // end of arguments

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        
               self->getMode(a0);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.getMode().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::getMode", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::setNoPlot
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::setNoPlot", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::setNoPlot";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("setNoPlot", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    bool
                    a0 =
                    (bool)
                    
                    context->argument( 0 ).
                    toBool();
                
    // end of arguments

    // call C++ function:
    // return type 'void'
    
               self->setNoPlot(a0);
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.setNoPlot().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::setNoPlot", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::getNoPlot
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::getNoPlot", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::getNoPlot";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("getNoPlot", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        
               self->getNoPlot();
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.getNoPlot().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::getNoPlot", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::setPixelUnit
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::setPixelUnit", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::setPixelUnit";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("setPixelUnit", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    bool
                    a0 =
                    (bool)
                    
                    context->argument( 0 ).
                    toBool();
                
    // end of arguments

    // call C++ function:
    // return type 'void'
    
               self->setPixelUnit(a0);
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.setPixelUnit().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::setPixelUnit", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::getPixelUnit
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::getPixelUnit", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::getPixelUnit";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("getPixelUnit", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        
               self->getPixelUnit();
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.getPixelUnit().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::getPixelUnit", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::setWorkingSet
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::setWorkingSet", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::setWorkingSet";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("setWorkingSet", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    bool
                    a0 =
                    (bool)
                    
                    context->argument( 0 ).
                    toBool();
                
    // end of arguments

    // call C++ function:
    // return type 'void'
    
               self->setWorkingSet(a0);
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.setWorkingSet().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::setWorkingSet", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::isWorkingSet
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::isWorkingSet", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::isWorkingSet";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("isWorkingSet", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        
               self->isWorkingSet();
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.isWorkingSet().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::isWorkingSet", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::getPainterPath
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::getPainterPath", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::getPainterPath";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("getPainterPath", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'RPainterPath &'
    RPainterPath & cppResult =
        
               self->getPainterPath();
        // return type: RPainterPath &
                // reference
                result = engine->newVariant(
                QVariant::fromValue(&cppResult));
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.getPainterPath().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::getPainterPath", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::getImage
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::getImage", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::getImage";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("getImage", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'RImageData &'
    RImageData & cppResult =
        
               self->getImage();
        // return type: RImageData &
                // reference
                result = engine->newVariant(
                QVariant::fromValue(&cppResult));
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.getImage().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::getImage", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::getText
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::getText", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::getText";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("getText", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'RTextBasedData &'
    RTextBasedData & cppResult =
        
               self->getText();
        // return type: RTextBasedData &
                // reference
                result = engine->newVariant(
                QVariant::fromValue(&cppResult));
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.getText().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::getText", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::getTransform
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::getTransform", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::getTransform";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("getTransform", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'RTransform &'
    RTransform & cppResult =
        
               self->getTransform();
        // return type: RTransform &
                // reference
                result = engine->newVariant(
                QVariant::fromValue(&cppResult));
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.getTransform().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::getTransform", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::getOffset
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::getOffset", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::getOffset";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("getOffset", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'RVector'
    RVector cppResult =
        
               self->getOffset();
        // return type: RVector
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.getOffset().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::getOffset", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::setOffset
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::setOffset", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::setOffset";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("setOffset", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RVector */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RVector*
                    ap0 =
                    qscriptvalue_cast<
                    RVector*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RVector.",
                               context);                    
                    }
                    RVector 
                    a0 = 
                    *ap0;
                
    // end of arguments

    // call C++ function:
    // return type 'void'
    
               self->setOffset(a0);
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.setOffset().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::setOffset", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::getDocument
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::getDocument", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::getDocument";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("getDocument", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'RDocument *'
    RDocument * cppResult =
        
               self->getDocument();
        // return type: RDocument *
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.getDocument().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::getDocument", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::setSelected
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::setSelected", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::setSelected";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("setSelected", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    bool
                    a0 =
                    (bool)
                    
                    context->argument( 0 ).
                    toBool();
                
    // end of arguments

    // call C++ function:
    // return type 'void'
    
               self->setSelected(a0);
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.setSelected().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::setSelected", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::setHighlighted
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::setHighlighted", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::setHighlighted";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("setHighlighted", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    bool
                    a0 =
                    (bool)
                    
                    context->argument( 0 ).
                    toBool();
                
    // end of arguments

    // call C++ function:
    // return type 'void'
    
               self->setHighlighted(a0);
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.setHighlighted().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::setHighlighted", context, engine);
            return result;
        }
         QScriptValue
        REcmaGraphicsSceneDrawable::operator_assign
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaGraphicsSceneDrawable::operator=", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaGraphicsSceneDrawable::operator=";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RGraphicsSceneDrawable* self = 
                        getSelf("operator=", context);
                  

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RGraphicsSceneDrawable */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RGraphicsSceneDrawable*
                    ap0 =
                    qscriptvalue_cast<
                    RGraphicsSceneDrawable*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RGraphicsSceneDrawable: Argument 0 is not of type RGraphicsSceneDrawable.",
                               context);                    
                    }
                    RGraphicsSceneDrawable 
                    a0 = 
                    *ap0;
                
    // end of arguments

    // call C++ function:
    // return type 'RGraphicsSceneDrawable &'
    RGraphicsSceneDrawable & cppResult =
        
               self->operator=(a0);
        // return type: RGraphicsSceneDrawable &
                // reference
                result = engine->newVariant(
                QVariant::fromValue(&cppResult));
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RGraphicsSceneDrawable.operator_assign().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaGraphicsSceneDrawable::operator=", context, engine);
            return result;
        }
         QScriptValue REcmaGraphicsSceneDrawable::toString
    (QScriptContext *context, QScriptEngine *engine)
    
    {

    RGraphicsSceneDrawable* self = getSelf("toString", context);
    
    QString result;
    
            QDebug d(&result);
            if (self!=NULL) {
                d << *self;
            }
            else {
                d << "NULL";
            }
        
    return QScriptValue(result);
    }
     QScriptValue REcmaGraphicsSceneDrawable::copy
    (QScriptContext *context, QScriptEngine *engine)
    
    {
        RGraphicsSceneDrawable cp = qscriptvalue_cast<RGraphicsSceneDrawable>(context->thisObject());
        return qScriptValueFromValue(engine, cp);
    }
     QScriptValue REcmaGraphicsSceneDrawable::destroy(QScriptContext *context, QScriptEngine *engine)
    
    {

        RGraphicsSceneDrawable* self = getSelf("RGraphicsSceneDrawable", context);
        //Q_ASSERT(self!=NULL);
        if (self==NULL) {
            return REcmaHelper::throwError("self is NULL", context);
        }
        
    
        delete self;
        context->thisObject().setData(engine->nullValue());
        context->thisObject().prototype().setData(engine->nullValue());
        context->thisObject().setPrototype(engine->nullValue());
        context->thisObject().setScriptClass(NULL);
        return engine->undefinedValue();
    }
    RGraphicsSceneDrawable* REcmaGraphicsSceneDrawable::getSelf(const QString& fName, QScriptContext* context)
    
        {
            RGraphicsSceneDrawable* self = NULL;

            
                // self could be a normal object (e.g. from an UI file) or
                // an ECMA shell object (made from an ECMA script):
                //self = getSelfShell(fName, context);
                

            //if (self==NULL) {
                self = REcmaHelper::scriptValueTo<RGraphicsSceneDrawable >(context->thisObject())
                
                ;
            //}

            if (self == NULL){
                // avoid recursion (toString is used by the backtrace):
                if (fName!="toString") {
                    REcmaHelper::throwError(QString("RGraphicsSceneDrawable.%1(): "
                        "This object is not a RGraphicsSceneDrawable").arg(fName),
                        context);
                }
                return NULL;
            }

            return self;
        }
        RGraphicsSceneDrawable* REcmaGraphicsSceneDrawable::getSelfShell(const QString& fName, QScriptContext* context)
    
        {
          RGraphicsSceneDrawable* selfBase = getSelf(fName, context);
                RGraphicsSceneDrawable* self = dynamic_cast<RGraphicsSceneDrawable*>(selfBase);
                //return REcmaHelper::scriptValueTo<RGraphicsSceneDrawable >(context->thisObject());
            if(self == NULL){
                REcmaHelper::throwError(QString("RGraphicsSceneDrawable.%1(): "
                    "This object is not a RGraphicsSceneDrawable").arg(fName),
                    context);
            }

            return self;
            


        }
         QScriptValue REcmaGraphicsSceneDrawable::toScriptValueEnumType(QScriptEngine* engine, const RGraphicsSceneDrawable::Type& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaGraphicsSceneDrawable::fromScriptValueEnumType(const QScriptValue& value, RGraphicsSceneDrawable::Type& out)
    
        {
            out = qvariant_cast<RGraphicsSceneDrawable::Type>(value.toVariant());
        }
         QScriptValue REcmaGraphicsSceneDrawable::toScriptValueEnumMode(QScriptEngine* engine, const RGraphicsSceneDrawable::Mode& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaGraphicsSceneDrawable::fromScriptValueEnumMode(const QScriptValue& value, RGraphicsSceneDrawable::Mode& out)
    
        {
            out = qvariant_cast<RGraphicsSceneDrawable::Mode>(value.toVariant());
        }
        