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

        // forwards declarations mapped to includes
        
                #include "RVector.h"
            
                #include "RPropertyAttributes.h"
            
            
        // includes for base ecma wrapper classes
         void REcmaS::initEcma(QScriptEngine& engine, QScriptValue* proto 
    
    ) 
    
    {

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

    

    QScriptValue fun;

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

    // 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:
    
        engine.setDefaultPrototype(
            qMetaTypeId<RS*>(), *proto);

        
    

    QScriptValue ctor = engine.newFunction(createEcma, *proto, 2);
    
    // static methods:
    
            REcmaHelper::registerFunction(&engine, &ctor, compare, "compare");
            
            REcmaHelper::registerFunction(&engine, &ctor, getCpuCores, "getCpuCores");
            
            REcmaHelper::registerFunction(&engine, &ctor, getIdealThreadCount, "getIdealThreadCount");
            
            REcmaHelper::registerFunction(&engine, &ctor, getBuildCpuArchitecture, "getBuildCpuArchitecture");
            
            REcmaHelper::registerFunction(&engine, &ctor, getHostId, "getHostId");
            
            REcmaHelper::registerFunction(&engine, &ctor, getSystemId, "getSystemId");
            
            REcmaHelper::registerFunction(&engine, &ctor, getWindowManagerId, "getWindowManagerId");
            
            REcmaHelper::registerFunction(&engine, &ctor, showInFileManager, "showInFileManager");
            
            REcmaHelper::registerFunction(&engine, &ctor, getDirectoryList, "getDirectoryList");
            
            REcmaHelper::registerFunction(&engine, &ctor, getFileList, "getFileList");
            
            REcmaHelper::registerFunction(&engine, &ctor, getFontList, "getFontList");
            
            REcmaHelper::registerFunction(&engine, &ctor, getPatternList, "getPatternList");
            
            REcmaHelper::registerFunction(&engine, &ctor, getLinetypeList, "getLinetypeList");
            
            REcmaHelper::registerFunction(&engine, &ctor, sortAlphanumerical, "sortAlphanumerical");
            
            REcmaHelper::registerFunction(&engine, &ctor, compareChunkify, "compareChunkify");
            
            REcmaHelper::registerFunction(&engine, &ctor, compareAlphanumerical, "compareAlphanumerical");
            
            REcmaHelper::registerFunction(&engine, &ctor, lessThanAlphanumerical, "lessThanAlphanumerical");
            

    // static properties:
    
            ctor.setProperty("PointTolerance",
                qScriptValueFromValue(&engine, RS::PointTolerance),
                QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
            
            ctor.setProperty("AngleTolerance",
                qScriptValueFromValue(&engine, RS::AngleTolerance),
                QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
            

    // enum values:
    

    ctor.setProperty("Print",
    QScriptValue(RS::Print),
    QScriptValue::ReadOnly);


    ctor.setProperty("Debug",
    QScriptValue(RS::Debug),
    QScriptValue::ReadOnly);


    ctor.setProperty("Warning",
    QScriptValue(RS::Warning),
    QScriptValue::ReadOnly);


    ctor.setProperty("Critical",
    QScriptValue(RS::Critical),
    QScriptValue::ReadOnly);


    ctor.setProperty("Command",
    QScriptValue(RS::Command),
    QScriptValue::ReadOnly);


    ctor.setProperty("ObjectAll",
    QScriptValue(RS::ObjectAll),
    QScriptValue::ReadOnly);


    ctor.setProperty("ObjectUnknown",
    QScriptValue(RS::ObjectUnknown),
    QScriptValue::ReadOnly);


    ctor.setProperty("ObjectLinetype",
    QScriptValue(RS::ObjectLinetype),
    QScriptValue::ReadOnly);


    ctor.setProperty("ObjectLayer",
    QScriptValue(RS::ObjectLayer),
    QScriptValue::ReadOnly);


    ctor.setProperty("ObjectBlock",
    QScriptValue(RS::ObjectBlock),
    QScriptValue::ReadOnly);


    ctor.setProperty("ObjectLayout",
    QScriptValue(RS::ObjectLayout),
    QScriptValue::ReadOnly);


    ctor.setProperty("ObjectLayerState",
    QScriptValue(RS::ObjectLayerState),
    QScriptValue::ReadOnly);


    ctor.setProperty("ObjectView",
    QScriptValue(RS::ObjectView),
    QScriptValue::ReadOnly);


    ctor.setProperty("ObjectUcs",
    QScriptValue(RS::ObjectUcs),
    QScriptValue::ReadOnly);


    ctor.setProperty("ObjectDocumentVariable",
    QScriptValue(RS::ObjectDocumentVariable),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityAll",
    QScriptValue(RS::EntityAll),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityUnknown",
    QScriptValue(RS::EntityUnknown),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityAttribute",
    QScriptValue(RS::EntityAttribute),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityAttributeDefinition",
    QScriptValue(RS::EntityAttributeDefinition),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityBlockRef",
    QScriptValue(RS::EntityBlockRef),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityBlockRefAttr",
    QScriptValue(RS::EntityBlockRefAttr),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityPoint",
    QScriptValue(RS::EntityPoint),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityLine",
    QScriptValue(RS::EntityLine),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityXLine",
    QScriptValue(RS::EntityXLine),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityRay",
    QScriptValue(RS::EntityRay),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityPolyline",
    QScriptValue(RS::EntityPolyline),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityArc",
    QScriptValue(RS::EntityArc),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityCircle",
    QScriptValue(RS::EntityCircle),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityEllipse",
    QScriptValue(RS::EntityEllipse),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntitySolid",
    QScriptValue(RS::EntitySolid),
    QScriptValue::ReadOnly);


    ctor.setProperty("Entity3dFace",
    QScriptValue(RS::Entity3dFace),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityTextBased",
    QScriptValue(RS::EntityTextBased),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityText",
    QScriptValue(RS::EntityText),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityTrace",
    QScriptValue(RS::EntityTrace),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityFace",
    QScriptValue(RS::EntityFace),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityDimension",
    QScriptValue(RS::EntityDimension),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityDimLinear",
    QScriptValue(RS::EntityDimLinear),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityDimAligned",
    QScriptValue(RS::EntityDimAligned),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityDimRotated",
    QScriptValue(RS::EntityDimRotated),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityDimRadial",
    QScriptValue(RS::EntityDimRadial),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityDimDiametric",
    QScriptValue(RS::EntityDimDiametric),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityDimAngular",
    QScriptValue(RS::EntityDimAngular),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityDimAngular2L",
    QScriptValue(RS::EntityDimAngular2L),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityDimAngular3P",
    QScriptValue(RS::EntityDimAngular3P),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityDimArcLength",
    QScriptValue(RS::EntityDimArcLength),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityDimOrdinate",
    QScriptValue(RS::EntityDimOrdinate),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityHatch",
    QScriptValue(RS::EntityHatch),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityImage",
    QScriptValue(RS::EntityImage),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityLeader",
    QScriptValue(RS::EntityLeader),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntitySpline",
    QScriptValue(RS::EntitySpline),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityViewport",
    QScriptValue(RS::EntityViewport),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityTolerance",
    QScriptValue(RS::EntityTolerance),
    QScriptValue::ReadOnly);


    ctor.setProperty("EntityUser",
    QScriptValue(RS::EntityUser),
    QScriptValue::ReadOnly);


    ctor.setProperty("RenderTop",
    QScriptValue(RS::RenderTop),
    QScriptValue::ReadOnly);


    ctor.setProperty("RenderSide",
    QScriptValue(RS::RenderSide),
    QScriptValue::ReadOnly);


    ctor.setProperty("RenderFront",
    QScriptValue(RS::RenderFront),
    QScriptValue::ReadOnly);


    ctor.setProperty("RenderThreeD",
    QScriptValue(RS::RenderThreeD),
    QScriptValue::ReadOnly);


    ctor.setProperty("OrthoVertical",
    QScriptValue(RS::OrthoVertical),
    QScriptValue::ReadOnly);


    ctor.setProperty("OrthoHorizonal",
    QScriptValue(RS::OrthoHorizonal),
    QScriptValue::ReadOnly);


    ctor.setProperty("Orthogonal",
    QScriptValue(RS::Orthogonal),
    QScriptValue::ReadOnly);


    ctor.setProperty("NoSide",
    QScriptValue(RS::NoSide),
    QScriptValue::ReadOnly);


    ctor.setProperty("LeftHand",
    QScriptValue(RS::LeftHand),
    QScriptValue::ReadOnly);


    ctor.setProperty("RightHand",
    QScriptValue(RS::RightHand),
    QScriptValue::ReadOnly);


    ctor.setProperty("BothSides",
    QScriptValue(RS::BothSides),
    QScriptValue::ReadOnly);


    ctor.setProperty("EndingStart",
    QScriptValue(RS::EndingStart),
    QScriptValue::ReadOnly);


    ctor.setProperty("EndingEnd",
    QScriptValue(RS::EndingEnd),
    QScriptValue::ReadOnly);


    ctor.setProperty("EndingNone",
    QScriptValue(RS::EndingNone),
    QScriptValue::ReadOnly);


    ctor.setProperty("VAlignTop",
    QScriptValue(RS::VAlignTop),
    QScriptValue::ReadOnly);


    ctor.setProperty("VAlignMiddle",
    QScriptValue(RS::VAlignMiddle),
    QScriptValue::ReadOnly);


    ctor.setProperty("VAlignBase",
    QScriptValue(RS::VAlignBase),
    QScriptValue::ReadOnly);


    ctor.setProperty("VAlignBottom",
    QScriptValue(RS::VAlignBottom),
    QScriptValue::ReadOnly);


    ctor.setProperty("HAlignLeft",
    QScriptValue(RS::HAlignLeft),
    QScriptValue::ReadOnly);


    ctor.setProperty("HAlignCenter",
    QScriptValue(RS::HAlignCenter),
    QScriptValue::ReadOnly);


    ctor.setProperty("HAlignRight",
    QScriptValue(RS::HAlignRight),
    QScriptValue::ReadOnly);


    ctor.setProperty("HAlignAlign",
    QScriptValue(RS::HAlignAlign),
    QScriptValue::ReadOnly);


    ctor.setProperty("HAlignMid",
    QScriptValue(RS::HAlignMid),
    QScriptValue::ReadOnly);


    ctor.setProperty("HAlignFit",
    QScriptValue(RS::HAlignFit),
    QScriptValue::ReadOnly);


    ctor.setProperty("LeftToRight",
    QScriptValue(RS::LeftToRight),
    QScriptValue::ReadOnly);


    ctor.setProperty("TopToBottom",
    QScriptValue(RS::TopToBottom),
    QScriptValue::ReadOnly);


    ctor.setProperty("ByStyle",
    QScriptValue(RS::ByStyle),
    QScriptValue::ReadOnly);


    ctor.setProperty("AtLeast",
    QScriptValue(RS::AtLeast),
    QScriptValue::ReadOnly);


    ctor.setProperty("Exact",
    QScriptValue(RS::Exact),
    QScriptValue::ReadOnly);


    ctor.setProperty("FromStart",
    QScriptValue(RS::FromStart),
    QScriptValue::ReadOnly);


    ctor.setProperty("FromEnd",
    QScriptValue(RS::FromEnd),
    QScriptValue::ReadOnly);


    ctor.setProperty("FromAny",
    QScriptValue(RS::FromAny),
    QScriptValue::ReadOnly);


    ctor.setProperty("AlongPolyline",
    QScriptValue(RS::AlongPolyline),
    QScriptValue::ReadOnly);


    ctor.setProperty("NoProjection",
    QScriptValue(RS::NoProjection),
    QScriptValue::ReadOnly);


    ctor.setProperty("Top",
    QScriptValue(RS::Top),
    QScriptValue::ReadOnly);


    ctor.setProperty("Bottom",
    QScriptValue(RS::Bottom),
    QScriptValue::ReadOnly);


    ctor.setProperty("Left",
    QScriptValue(RS::Left),
    QScriptValue::ReadOnly);


    ctor.setProperty("LeftBack",
    QScriptValue(RS::LeftBack),
    QScriptValue::ReadOnly);


    ctor.setProperty("Right",
    QScriptValue(RS::Right),
    QScriptValue::ReadOnly);


    ctor.setProperty("RightBack",
    QScriptValue(RS::RightBack),
    QScriptValue::ReadOnly);


    ctor.setProperty("Isometric",
    QScriptValue(RS::Isometric),
    QScriptValue::ReadOnly);


    ctor.setProperty("IsometricTrue",
    QScriptValue(RS::IsometricTrue),
    QScriptValue::ReadOnly);


    ctor.setProperty("Planometric",
    QScriptValue(RS::Planometric),
    QScriptValue::ReadOnly);


    ctor.setProperty("Dimetric",
    QScriptValue(RS::Dimetric),
    QScriptValue::ReadOnly);


    ctor.setProperty("Cabinet",
    QScriptValue(RS::Cabinet),
    QScriptValue::ReadOnly);


    ctor.setProperty("Cabinet30",
    QScriptValue(RS::Cabinet30),
    QScriptValue::ReadOnly);


    ctor.setProperty("Cavalier",
    QScriptValue(RS::Cavalier),
    QScriptValue::ReadOnly);


    ctor.setProperty("User1",
    QScriptValue(RS::User1),
    QScriptValue::ReadOnly);


    ctor.setProperty("User2",
    QScriptValue(RS::User2),
    QScriptValue::ReadOnly);


    ctor.setProperty("User3",
    QScriptValue(RS::User3),
    QScriptValue::ReadOnly);


    ctor.setProperty("User4",
    QScriptValue(RS::User4),
    QScriptValue::ReadOnly);


    ctor.setProperty("IsoTop",
    QScriptValue(RS::IsoTop),
    QScriptValue::ReadOnly);


    ctor.setProperty("IsoBottom",
    QScriptValue(RS::IsoBottom),
    QScriptValue::ReadOnly);


    ctor.setProperty("IsoLeft",
    QScriptValue(RS::IsoLeft),
    QScriptValue::ReadOnly);


    ctor.setProperty("IsoLeftBack",
    QScriptValue(RS::IsoLeftBack),
    QScriptValue::ReadOnly);


    ctor.setProperty("IsoRight",
    QScriptValue(RS::IsoRight),
    QScriptValue::ReadOnly);


    ctor.setProperty("IsoRightBack",
    QScriptValue(RS::IsoRightBack),
    QScriptValue::ReadOnly);


    ctor.setProperty("UnknownMeasurement",
    QScriptValue(RS::UnknownMeasurement),
    QScriptValue::ReadOnly);


    ctor.setProperty("Imperial",
    QScriptValue(RS::Imperial),
    QScriptValue::ReadOnly);


    ctor.setProperty("Metric",
    QScriptValue(RS::Metric),
    QScriptValue::ReadOnly);


    ctor.setProperty("None",
    QScriptValue(RS::None),
    QScriptValue::ReadOnly);


    ctor.setProperty("Inch",
    QScriptValue(RS::Inch),
    QScriptValue::ReadOnly);


    ctor.setProperty("Foot",
    QScriptValue(RS::Foot),
    QScriptValue::ReadOnly);


    ctor.setProperty("Mile",
    QScriptValue(RS::Mile),
    QScriptValue::ReadOnly);


    ctor.setProperty("Millimeter",
    QScriptValue(RS::Millimeter),
    QScriptValue::ReadOnly);


    ctor.setProperty("Centimeter",
    QScriptValue(RS::Centimeter),
    QScriptValue::ReadOnly);


    ctor.setProperty("Meter",
    QScriptValue(RS::Meter),
    QScriptValue::ReadOnly);


    ctor.setProperty("Kilometer",
    QScriptValue(RS::Kilometer),
    QScriptValue::ReadOnly);


    ctor.setProperty("Microinch",
    QScriptValue(RS::Microinch),
    QScriptValue::ReadOnly);


    ctor.setProperty("Mil",
    QScriptValue(RS::Mil),
    QScriptValue::ReadOnly);


    ctor.setProperty("Yard",
    QScriptValue(RS::Yard),
    QScriptValue::ReadOnly);


    ctor.setProperty("Angstrom",
    QScriptValue(RS::Angstrom),
    QScriptValue::ReadOnly);


    ctor.setProperty("Nanometer",
    QScriptValue(RS::Nanometer),
    QScriptValue::ReadOnly);


    ctor.setProperty("Micron",
    QScriptValue(RS::Micron),
    QScriptValue::ReadOnly);


    ctor.setProperty("Decimeter",
    QScriptValue(RS::Decimeter),
    QScriptValue::ReadOnly);


    ctor.setProperty("Decameter",
    QScriptValue(RS::Decameter),
    QScriptValue::ReadOnly);


    ctor.setProperty("Hectometer",
    QScriptValue(RS::Hectometer),
    QScriptValue::ReadOnly);


    ctor.setProperty("Gigameter",
    QScriptValue(RS::Gigameter),
    QScriptValue::ReadOnly);


    ctor.setProperty("Astro",
    QScriptValue(RS::Astro),
    QScriptValue::ReadOnly);


    ctor.setProperty("Lightyear",
    QScriptValue(RS::Lightyear),
    QScriptValue::ReadOnly);


    ctor.setProperty("Parsec",
    QScriptValue(RS::Parsec),
    QScriptValue::ReadOnly);


    ctor.setProperty("MaxUnit",
    QScriptValue(RS::MaxUnit),
    QScriptValue::ReadOnly);


    ctor.setProperty("DegreesDecimal",
    QScriptValue(RS::DegreesDecimal),
    QScriptValue::ReadOnly);


    ctor.setProperty("DegreesMinutesSeconds",
    QScriptValue(RS::DegreesMinutesSeconds),
    QScriptValue::ReadOnly);


    ctor.setProperty("Gradians",
    QScriptValue(RS::Gradians),
    QScriptValue::ReadOnly);


    ctor.setProperty("Radians",
    QScriptValue(RS::Radians),
    QScriptValue::ReadOnly);


    ctor.setProperty("Surveyors",
    QScriptValue(RS::Surveyors),
    QScriptValue::ReadOnly);


    ctor.setProperty("Scientific",
    QScriptValue(RS::Scientific),
    QScriptValue::ReadOnly);


    ctor.setProperty("Decimal",
    QScriptValue(RS::Decimal),
    QScriptValue::ReadOnly);


    ctor.setProperty("Engineering",
    QScriptValue(RS::Engineering),
    QScriptValue::ReadOnly);


    ctor.setProperty("ArchitecturalStacked",
    QScriptValue(RS::ArchitecturalStacked),
    QScriptValue::ReadOnly);


    ctor.setProperty("FractionalStacked",
    QScriptValue(RS::FractionalStacked),
    QScriptValue::ReadOnly);


    ctor.setProperty("Architectural",
    QScriptValue(RS::Architectural),
    QScriptValue::ReadOnly);


    ctor.setProperty("Fractional",
    QScriptValue(RS::Fractional),
    QScriptValue::ReadOnly);


    ctor.setProperty("WindowsDesktop",
    QScriptValue(RS::WindowsDesktop),
    QScriptValue::ReadOnly);


    ctor.setProperty("Deg",
    QScriptValue(RS::Deg),
    QScriptValue::ReadOnly);


    ctor.setProperty("Rad",
    QScriptValue(RS::Rad),
    QScriptValue::ReadOnly);


    ctor.setProperty("Gra",
    QScriptValue(RS::Gra),
    QScriptValue::ReadOnly);


    ctor.setProperty("ANGBASE",
    QScriptValue(RS::ANGBASE),
    QScriptValue::ReadOnly);


    ctor.setProperty("ANGDIR",
    QScriptValue(RS::ANGDIR),
    QScriptValue::ReadOnly);


    ctor.setProperty("ATTMODE",
    QScriptValue(RS::ATTMODE),
    QScriptValue::ReadOnly);


    ctor.setProperty("AUNITS",
    QScriptValue(RS::AUNITS),
    QScriptValue::ReadOnly);


    ctor.setProperty("AUPREC",
    QScriptValue(RS::AUPREC),
    QScriptValue::ReadOnly);


    ctor.setProperty("CECOLOR",
    QScriptValue(RS::CECOLOR),
    QScriptValue::ReadOnly);


    ctor.setProperty("CELTSCALE",
    QScriptValue(RS::CELTSCALE),
    QScriptValue::ReadOnly);


    ctor.setProperty("CHAMFERA",
    QScriptValue(RS::CHAMFERA),
    QScriptValue::ReadOnly);


    ctor.setProperty("CHAMFERB",
    QScriptValue(RS::CHAMFERB),
    QScriptValue::ReadOnly);


    ctor.setProperty("CHAMFERC",
    QScriptValue(RS::CHAMFERC),
    QScriptValue::ReadOnly);


    ctor.setProperty("CHAMFERD",
    QScriptValue(RS::CHAMFERD),
    QScriptValue::ReadOnly);


    ctor.setProperty("CLAYER",
    QScriptValue(RS::CLAYER),
    QScriptValue::ReadOnly);


    ctor.setProperty("CMLJUST",
    QScriptValue(RS::CMLJUST),
    QScriptValue::ReadOnly);


    ctor.setProperty("CMLSCALE",
    QScriptValue(RS::CMLSCALE),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMADEC",
    QScriptValue(RS::DIMADEC),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMALT",
    QScriptValue(RS::DIMALT),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMALTD",
    QScriptValue(RS::DIMALTD),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMALTF",
    QScriptValue(RS::DIMALTF),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMALTRND",
    QScriptValue(RS::DIMALTRND),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMALTTD",
    QScriptValue(RS::DIMALTTD),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMALTTZ",
    QScriptValue(RS::DIMALTTZ),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMALTU",
    QScriptValue(RS::DIMALTU),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMALTZ",
    QScriptValue(RS::DIMALTZ),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMAPOST",
    QScriptValue(RS::DIMAPOST),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMASZ",
    QScriptValue(RS::DIMASZ),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMATFIT",
    QScriptValue(RS::DIMATFIT),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMAUNIT",
    QScriptValue(RS::DIMAUNIT),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMAZIN",
    QScriptValue(RS::DIMAZIN),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMBLK",
    QScriptValue(RS::DIMBLK),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMBLK1",
    QScriptValue(RS::DIMBLK1),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMBLK2",
    QScriptValue(RS::DIMBLK2),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMCEN",
    QScriptValue(RS::DIMCEN),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMCLRD",
    QScriptValue(RS::DIMCLRD),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMCLRE",
    QScriptValue(RS::DIMCLRE),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMCLRT",
    QScriptValue(RS::DIMCLRT),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMDEC",
    QScriptValue(RS::DIMDEC),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMDLE",
    QScriptValue(RS::DIMDLE),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMDLI",
    QScriptValue(RS::DIMDLI),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMDSEP",
    QScriptValue(RS::DIMDSEP),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMEXE",
    QScriptValue(RS::DIMEXE),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMEXO",
    QScriptValue(RS::DIMEXO),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMFRAC",
    QScriptValue(RS::DIMFRAC),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMGAP",
    QScriptValue(RS::DIMGAP),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMJUST",
    QScriptValue(RS::DIMJUST),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMLDRBLK",
    QScriptValue(RS::DIMLDRBLK),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMLFAC",
    QScriptValue(RS::DIMLFAC),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMLIM",
    QScriptValue(RS::DIMLIM),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMLUNIT",
    QScriptValue(RS::DIMLUNIT),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMLWD",
    QScriptValue(RS::DIMLWD),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMLWE",
    QScriptValue(RS::DIMLWE),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMPOST",
    QScriptValue(RS::DIMPOST),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMRND",
    QScriptValue(RS::DIMRND),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMSAH",
    QScriptValue(RS::DIMSAH),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMSCALE",
    QScriptValue(RS::DIMSCALE),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMSD1",
    QScriptValue(RS::DIMSD1),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMSD2",
    QScriptValue(RS::DIMSD2),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMSE1",
    QScriptValue(RS::DIMSE1),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMSE2",
    QScriptValue(RS::DIMSE2),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMSOXD",
    QScriptValue(RS::DIMSOXD),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTAD",
    QScriptValue(RS::DIMTAD),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTDEC",
    QScriptValue(RS::DIMTDEC),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTFAC",
    QScriptValue(RS::DIMTFAC),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTIH",
    QScriptValue(RS::DIMTIH),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTIX",
    QScriptValue(RS::DIMTIX),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTM",
    QScriptValue(RS::DIMTM),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTOFL",
    QScriptValue(RS::DIMTOFL),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTOH",
    QScriptValue(RS::DIMTOH),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTOL",
    QScriptValue(RS::DIMTOL),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTOLJ",
    QScriptValue(RS::DIMTOLJ),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTP",
    QScriptValue(RS::DIMTP),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTSZ",
    QScriptValue(RS::DIMTSZ),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTVP",
    QScriptValue(RS::DIMTVP),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTXSTY",
    QScriptValue(RS::DIMTXSTY),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTXT",
    QScriptValue(RS::DIMTXT),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMTZIN",
    QScriptValue(RS::DIMTZIN),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMUPT",
    QScriptValue(RS::DIMUPT),
    QScriptValue::ReadOnly);


    ctor.setProperty("DIMZIN",
    QScriptValue(RS::DIMZIN),
    QScriptValue::ReadOnly);


    ctor.setProperty("DISPSILH",
    QScriptValue(RS::DISPSILH),
    QScriptValue::ReadOnly);


    ctor.setProperty("DWGCODEPAGE",
    QScriptValue(RS::DWGCODEPAGE),
    QScriptValue::ReadOnly);


    ctor.setProperty("DRAWORDERCTL",
    QScriptValue(RS::DRAWORDERCTL),
    QScriptValue::ReadOnly);


    ctor.setProperty("ELEVATION",
    QScriptValue(RS::ELEVATION),
    QScriptValue::ReadOnly);


    ctor.setProperty("EXTMAX",
    QScriptValue(RS::EXTMAX),
    QScriptValue::ReadOnly);


    ctor.setProperty("EXTMIN",
    QScriptValue(RS::EXTMIN),
    QScriptValue::ReadOnly);


    ctor.setProperty("FACETRES",
    QScriptValue(RS::FACETRES),
    QScriptValue::ReadOnly);


    ctor.setProperty("FILLETRAD",
    QScriptValue(RS::FILLETRAD),
    QScriptValue::ReadOnly);


    ctor.setProperty("FILLMODE",
    QScriptValue(RS::FILLMODE),
    QScriptValue::ReadOnly);


    ctor.setProperty("INSBASE",
    QScriptValue(RS::INSBASE),
    QScriptValue::ReadOnly);


    ctor.setProperty("INSUNITS",
    QScriptValue(RS::INSUNITS),
    QScriptValue::ReadOnly);


    ctor.setProperty("ISOLINES",
    QScriptValue(RS::ISOLINES),
    QScriptValue::ReadOnly);


    ctor.setProperty("LIMCHECK",
    QScriptValue(RS::LIMCHECK),
    QScriptValue::ReadOnly);


    ctor.setProperty("LIMMAX",
    QScriptValue(RS::LIMMAX),
    QScriptValue::ReadOnly);


    ctor.setProperty("LIMMIN",
    QScriptValue(RS::LIMMIN),
    QScriptValue::ReadOnly);


    ctor.setProperty("LTSCALE",
    QScriptValue(RS::LTSCALE),
    QScriptValue::ReadOnly);


    ctor.setProperty("LUNITS",
    QScriptValue(RS::LUNITS),
    QScriptValue::ReadOnly);


    ctor.setProperty("LUPREC",
    QScriptValue(RS::LUPREC),
    QScriptValue::ReadOnly);


    ctor.setProperty("MAXACTVP",
    QScriptValue(RS::MAXACTVP),
    QScriptValue::ReadOnly);


    ctor.setProperty("MEASUREMENT",
    QScriptValue(RS::MEASUREMENT),
    QScriptValue::ReadOnly);


    ctor.setProperty("MIRRTEXT",
    QScriptValue(RS::MIRRTEXT),
    QScriptValue::ReadOnly);


    ctor.setProperty("ORTHOMODE",
    QScriptValue(RS::ORTHOMODE),
    QScriptValue::ReadOnly);


    ctor.setProperty("PDMODE",
    QScriptValue(RS::PDMODE),
    QScriptValue::ReadOnly);


    ctor.setProperty("PDSIZE",
    QScriptValue(RS::PDSIZE),
    QScriptValue::ReadOnly);


    ctor.setProperty("PELEVATION",
    QScriptValue(RS::PELEVATION),
    QScriptValue::ReadOnly);


    ctor.setProperty("PELLIPSE",
    QScriptValue(RS::PELLIPSE),
    QScriptValue::ReadOnly);


    ctor.setProperty("PEXTMAX",
    QScriptValue(RS::PEXTMAX),
    QScriptValue::ReadOnly);


    ctor.setProperty("PEXTMIN",
    QScriptValue(RS::PEXTMIN),
    QScriptValue::ReadOnly);


    ctor.setProperty("PINSBASE",
    QScriptValue(RS::PINSBASE),
    QScriptValue::ReadOnly);


    ctor.setProperty("PLIMCHECK",
    QScriptValue(RS::PLIMCHECK),
    QScriptValue::ReadOnly);


    ctor.setProperty("PLIMMAX",
    QScriptValue(RS::PLIMMAX),
    QScriptValue::ReadOnly);


    ctor.setProperty("PLIMMIN",
    QScriptValue(RS::PLIMMIN),
    QScriptValue::ReadOnly);


    ctor.setProperty("PLINEGEN",
    QScriptValue(RS::PLINEGEN),
    QScriptValue::ReadOnly);


    ctor.setProperty("PLINEWID",
    QScriptValue(RS::PLINEWID),
    QScriptValue::ReadOnly);


    ctor.setProperty("PROXYGRAPHICS",
    QScriptValue(RS::PROXYGRAPHICS),
    QScriptValue::ReadOnly);


    ctor.setProperty("PSLTSCALE",
    QScriptValue(RS::PSLTSCALE),
    QScriptValue::ReadOnly);


    ctor.setProperty("PUCSNAME",
    QScriptValue(RS::PUCSNAME),
    QScriptValue::ReadOnly);


    ctor.setProperty("PUCSORG",
    QScriptValue(RS::PUCSORG),
    QScriptValue::ReadOnly);


    ctor.setProperty("PUCSXDIR",
    QScriptValue(RS::PUCSXDIR),
    QScriptValue::ReadOnly);


    ctor.setProperty("PUCSYDIR",
    QScriptValue(RS::PUCSYDIR),
    QScriptValue::ReadOnly);


    ctor.setProperty("QTEXTMODE",
    QScriptValue(RS::QTEXTMODE),
    QScriptValue::ReadOnly);


    ctor.setProperty("REGENMODE",
    QScriptValue(RS::REGENMODE),
    QScriptValue::ReadOnly);


    ctor.setProperty("SHADEDGE",
    QScriptValue(RS::SHADEDGE),
    QScriptValue::ReadOnly);


    ctor.setProperty("SHADEDIF",
    QScriptValue(RS::SHADEDIF),
    QScriptValue::ReadOnly);


    ctor.setProperty("SKETCHINC",
    QScriptValue(RS::SKETCHINC),
    QScriptValue::ReadOnly);


    ctor.setProperty("SKPOLY",
    QScriptValue(RS::SKPOLY),
    QScriptValue::ReadOnly);


    ctor.setProperty("SPLFRAME",
    QScriptValue(RS::SPLFRAME),
    QScriptValue::ReadOnly);


    ctor.setProperty("SPLINESEGS",
    QScriptValue(RS::SPLINESEGS),
    QScriptValue::ReadOnly);


    ctor.setProperty("SPLINETYPE",
    QScriptValue(RS::SPLINETYPE),
    QScriptValue::ReadOnly);


    ctor.setProperty("SURFTAB1",
    QScriptValue(RS::SURFTAB1),
    QScriptValue::ReadOnly);


    ctor.setProperty("SURFTAB2",
    QScriptValue(RS::SURFTAB2),
    QScriptValue::ReadOnly);


    ctor.setProperty("SURFTYPE",
    QScriptValue(RS::SURFTYPE),
    QScriptValue::ReadOnly);


    ctor.setProperty("SURFU",
    QScriptValue(RS::SURFU),
    QScriptValue::ReadOnly);


    ctor.setProperty("SURFV",
    QScriptValue(RS::SURFV),
    QScriptValue::ReadOnly);


    ctor.setProperty("TEXTQLTY",
    QScriptValue(RS::TEXTQLTY),
    QScriptValue::ReadOnly);


    ctor.setProperty("TEXTSIZE",
    QScriptValue(RS::TEXTSIZE),
    QScriptValue::ReadOnly);


    ctor.setProperty("TEXTSTYLE",
    QScriptValue(RS::TEXTSTYLE),
    QScriptValue::ReadOnly);


    ctor.setProperty("THICKNESS",
    QScriptValue(RS::THICKNESS),
    QScriptValue::ReadOnly);


    ctor.setProperty("TILEMODE",
    QScriptValue(RS::TILEMODE),
    QScriptValue::ReadOnly);


    ctor.setProperty("TRACEWID",
    QScriptValue(RS::TRACEWID),
    QScriptValue::ReadOnly);


    ctor.setProperty("TREEDEPTH",
    QScriptValue(RS::TREEDEPTH),
    QScriptValue::ReadOnly);


    ctor.setProperty("UCSNAME",
    QScriptValue(RS::UCSNAME),
    QScriptValue::ReadOnly);


    ctor.setProperty("UCSORG",
    QScriptValue(RS::UCSORG),
    QScriptValue::ReadOnly);


    ctor.setProperty("UCSXDIR",
    QScriptValue(RS::UCSXDIR),
    QScriptValue::ReadOnly);


    ctor.setProperty("UCSYDIR",
    QScriptValue(RS::UCSYDIR),
    QScriptValue::ReadOnly);


    ctor.setProperty("UNITMODE",
    QScriptValue(RS::UNITMODE),
    QScriptValue::ReadOnly);


    ctor.setProperty("USERI1",
    QScriptValue(RS::USERI1),
    QScriptValue::ReadOnly);


    ctor.setProperty("USERI2",
    QScriptValue(RS::USERI2),
    QScriptValue::ReadOnly);


    ctor.setProperty("USERI3",
    QScriptValue(RS::USERI3),
    QScriptValue::ReadOnly);


    ctor.setProperty("USERI4",
    QScriptValue(RS::USERI4),
    QScriptValue::ReadOnly);


    ctor.setProperty("USERI5",
    QScriptValue(RS::USERI5),
    QScriptValue::ReadOnly);


    ctor.setProperty("USERR1",
    QScriptValue(RS::USERR1),
    QScriptValue::ReadOnly);


    ctor.setProperty("USERR2",
    QScriptValue(RS::USERR2),
    QScriptValue::ReadOnly);


    ctor.setProperty("USERR3",
    QScriptValue(RS::USERR3),
    QScriptValue::ReadOnly);


    ctor.setProperty("USERR4",
    QScriptValue(RS::USERR4),
    QScriptValue::ReadOnly);


    ctor.setProperty("USERR5",
    QScriptValue(RS::USERR5),
    QScriptValue::ReadOnly);


    ctor.setProperty("USRTIMER",
    QScriptValue(RS::USRTIMER),
    QScriptValue::ReadOnly);


    ctor.setProperty("VISRETAIN",
    QScriptValue(RS::VISRETAIN),
    QScriptValue::ReadOnly);


    ctor.setProperty("WORLDVIEW",
    QScriptValue(RS::WORLDVIEW),
    QScriptValue::ReadOnly);


    ctor.setProperty("MaxKnownVariable",
    QScriptValue(RS::MaxKnownVariable),
    QScriptValue::ReadOnly);


    ctor.setProperty("INVALID",
    QScriptValue(RS::INVALID),
    QScriptValue::ReadOnly);


    ctor.setProperty("Intersection",
    QScriptValue(RS::Intersection),
    QScriptValue::ReadOnly);


    ctor.setProperty("Union",
    QScriptValue(RS::Union),
    QScriptValue::ReadOnly);


    ctor.setProperty("Difference",
    QScriptValue(RS::Difference),
    QScriptValue::ReadOnly);


    ctor.setProperty("Xor",
    QScriptValue(RS::Xor),
    QScriptValue::ReadOnly);


    ctor.setProperty("EvenOdd",
    QScriptValue(RS::EvenOdd),
    QScriptValue::ReadOnly);


    ctor.setProperty("NonZero",
    QScriptValue(RS::NonZero),
    QScriptValue::ReadOnly);


    ctor.setProperty("Positive",
    QScriptValue(RS::Positive),
    QScriptValue::ReadOnly);


    ctor.setProperty("Negative",
    QScriptValue(RS::Negative),
    QScriptValue::ReadOnly);


    ctor.setProperty("UnknownOrientation",
    QScriptValue(RS::UnknownOrientation),
    QScriptValue::ReadOnly);


    ctor.setProperty("Any",
    QScriptValue(RS::Any),
    QScriptValue::ReadOnly);


    ctor.setProperty("CW",
    QScriptValue(RS::CW),
    QScriptValue::ReadOnly);


    ctor.setProperty("CCW",
    QScriptValue(RS::CCW),
    QScriptValue::ReadOnly);


    ctor.setProperty("JoinBevel",
    QScriptValue(RS::JoinBevel),
    QScriptValue::ReadOnly);


    ctor.setProperty("JoinRound",
    QScriptValue(RS::JoinRound),
    QScriptValue::ReadOnly);


    ctor.setProperty("JoinMiter",
    QScriptValue(RS::JoinMiter),
    QScriptValue::ReadOnly);


    ctor.setProperty("EndClosedPolygon",
    QScriptValue(RS::EndClosedPolygon),
    QScriptValue::ReadOnly);


    ctor.setProperty("EndClosedLine",
    QScriptValue(RS::EndClosedLine),
    QScriptValue::ReadOnly);


    ctor.setProperty("EndOpenButt",
    QScriptValue(RS::EndOpenButt),
    QScriptValue::ReadOnly);


    ctor.setProperty("EndOpenSquare",
    QScriptValue(RS::EndOpenSquare),
    QScriptValue::ReadOnly);


    ctor.setProperty("EndOpenRound",
    QScriptValue(RS::EndOpenRound),
    QScriptValue::ReadOnly);


    ctor.setProperty("EndOpenSingle",
    QScriptValue(RS::EndOpenSingle),
    QScriptValue::ReadOnly);


    ctor.setProperty("Linear",
    QScriptValue(RS::Linear),
    QScriptValue::ReadOnly);


    ctor.setProperty("InQuad",
    QScriptValue(RS::InQuad),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutQuad",
    QScriptValue(RS::OutQuad),
    QScriptValue::ReadOnly);


    ctor.setProperty("InOutQuad",
    QScriptValue(RS::InOutQuad),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutInQuad",
    QScriptValue(RS::OutInQuad),
    QScriptValue::ReadOnly);


    ctor.setProperty("InCubic",
    QScriptValue(RS::InCubic),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutCubic",
    QScriptValue(RS::OutCubic),
    QScriptValue::ReadOnly);


    ctor.setProperty("InOutCubic",
    QScriptValue(RS::InOutCubic),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutInCubic",
    QScriptValue(RS::OutInCubic),
    QScriptValue::ReadOnly);


    ctor.setProperty("InQuart",
    QScriptValue(RS::InQuart),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutQuart",
    QScriptValue(RS::OutQuart),
    QScriptValue::ReadOnly);


    ctor.setProperty("InOutQuart",
    QScriptValue(RS::InOutQuart),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutInQuart",
    QScriptValue(RS::OutInQuart),
    QScriptValue::ReadOnly);


    ctor.setProperty("InQuint",
    QScriptValue(RS::InQuint),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutQuint",
    QScriptValue(RS::OutQuint),
    QScriptValue::ReadOnly);


    ctor.setProperty("InOutQuint",
    QScriptValue(RS::InOutQuint),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutInQuint",
    QScriptValue(RS::OutInQuint),
    QScriptValue::ReadOnly);


    ctor.setProperty("InSine",
    QScriptValue(RS::InSine),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutSine",
    QScriptValue(RS::OutSine),
    QScriptValue::ReadOnly);


    ctor.setProperty("InOutSine",
    QScriptValue(RS::InOutSine),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutInSine",
    QScriptValue(RS::OutInSine),
    QScriptValue::ReadOnly);


    ctor.setProperty("InExpo",
    QScriptValue(RS::InExpo),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutExpo",
    QScriptValue(RS::OutExpo),
    QScriptValue::ReadOnly);


    ctor.setProperty("InOutExpo",
    QScriptValue(RS::InOutExpo),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutInExpo",
    QScriptValue(RS::OutInExpo),
    QScriptValue::ReadOnly);


    ctor.setProperty("InCirc",
    QScriptValue(RS::InCirc),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutCirc",
    QScriptValue(RS::OutCirc),
    QScriptValue::ReadOnly);


    ctor.setProperty("InOutCirc",
    QScriptValue(RS::InOutCirc),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutInCirc",
    QScriptValue(RS::OutInCirc),
    QScriptValue::ReadOnly);


    ctor.setProperty("InElastic",
    QScriptValue(RS::InElastic),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutElastic",
    QScriptValue(RS::OutElastic),
    QScriptValue::ReadOnly);


    ctor.setProperty("InOutElastic",
    QScriptValue(RS::InOutElastic),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutInElastic",
    QScriptValue(RS::OutInElastic),
    QScriptValue::ReadOnly);


    ctor.setProperty("InBack",
    QScriptValue(RS::InBack),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutBack",
    QScriptValue(RS::OutBack),
    QScriptValue::ReadOnly);


    ctor.setProperty("InOutBack",
    QScriptValue(RS::InOutBack),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutInBack",
    QScriptValue(RS::OutInBack),
    QScriptValue::ReadOnly);


    ctor.setProperty("InBounce",
    QScriptValue(RS::InBounce),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutBounce",
    QScriptValue(RS::OutBounce),
    QScriptValue::ReadOnly);


    ctor.setProperty("InOutBounce",
    QScriptValue(RS::InOutBounce),
    QScriptValue::ReadOnly);


    ctor.setProperty("OutInBounce",
    QScriptValue(RS::OutInBounce),
    QScriptValue::ReadOnly);


    // enum conversions:
    
    qScriptRegisterMetaType<RS::MessageType>(
        &engine,
        toScriptValueEnumMessageType,
        fromScriptValueEnumMessageType,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::EntityType>(
        &engine,
        toScriptValueEnumEntityType,
        fromScriptValueEnumEntityType,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::ProjectionRenderingHint>(
        &engine,
        toScriptValueEnumProjectionRenderingHint,
        fromScriptValueEnumProjectionRenderingHint,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::OrthoMode>(
        &engine,
        toScriptValueEnumOrthoMode,
        fromScriptValueEnumOrthoMode,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::Side>(
        &engine,
        toScriptValueEnumSide,
        fromScriptValueEnumSide,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::Ending>(
        &engine,
        toScriptValueEnumEnding,
        fromScriptValueEnumEnding,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::VAlign>(
        &engine,
        toScriptValueEnumVAlign,
        fromScriptValueEnumVAlign,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::HAlign>(
        &engine,
        toScriptValueEnumHAlign,
        fromScriptValueEnumHAlign,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::TextDrawingDirection>(
        &engine,
        toScriptValueEnumTextDrawingDirection,
        fromScriptValueEnumTextDrawingDirection,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::TextLineSpacingStyle>(
        &engine,
        toScriptValueEnumTextLineSpacingStyle,
        fromScriptValueEnumTextLineSpacingStyle,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::From>(
        &engine,
        toScriptValueEnumFrom,
        fromScriptValueEnumFrom,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::IsoProjectionType>(
        &engine,
        toScriptValueEnumIsoProjectionType,
        fromScriptValueEnumIsoProjectionType,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::Measurement>(
        &engine,
        toScriptValueEnumMeasurement,
        fromScriptValueEnumMeasurement,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::Unit>(
        &engine,
        toScriptValueEnumUnit,
        fromScriptValueEnumUnit,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::AngleFormat>(
        &engine,
        toScriptValueEnumAngleFormat,
        fromScriptValueEnumAngleFormat,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::LinearFormat>(
        &engine,
        toScriptValueEnumLinearFormat,
        fromScriptValueEnumLinearFormat,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::AngleUnit>(
        &engine,
        toScriptValueEnumAngleUnit,
        fromScriptValueEnumAngleUnit,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::KnownVariable>(
        &engine,
        toScriptValueEnumKnownVariable,
        fromScriptValueEnumKnownVariable,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::BooleanOperation>(
        &engine,
        toScriptValueEnumBooleanOperation,
        fromScriptValueEnumBooleanOperation,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::FillType>(
        &engine,
        toScriptValueEnumFillType,
        fromScriptValueEnumFillType,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::Orientation>(
        &engine,
        toScriptValueEnumOrientation,
        fromScriptValueEnumOrientation,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::JoinType>(
        &engine,
        toScriptValueEnumJoinType,
        fromScriptValueEnumJoinType,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::EndType>(
        &engine,
        toScriptValueEnumEndType,
        fromScriptValueEnumEndType,
        ctor.property(QString::fromLatin1("prototype"))
    );

    qScriptRegisterMetaType<RS::Easing>(
        &engine,
        toScriptValueEnumEasing,
        fromScriptValueEnumEasing,
        ctor.property(QString::fromLatin1("prototype"))
    );

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

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

    // call C++ constructor:
    
            // non-copyable class:
            RS
                    * cppResult =
                    new
                    RS
                    ();
                
                    // TODO: triggers: Warning: QScriptEngine::newVariant(): changing class of non-QScriptObject not supported:
                    result = engine->newVariant(context->thisObject(), qVariantFromValue(cppResult));
                
    } else 

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

    // conversion functions for base classes:
    

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

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

        return qScriptValueFromSequence(engine, list);
    }
    

    // properties:
    

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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNumber() || 
            context->argument(0).isString() || 
            context->argument(0).isBool() || 
            context->argument(0).isArray() || 
            context->argument(0).isNull() || 
            context->argument(0).isUndefined()
        ) /* type: QVariant */
     && (
            context->argument(1).isVariant() || 
            context->argument(1).isQObject() || 
            context->argument(1).isNumber() || 
            context->argument(1).isString() || 
            context->argument(1).isBool() || 
            context->argument(1).isArray() || 
            context->argument(1).isNull() || 
            context->argument(1).isUndefined()
        ) /* type: QVariant */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable or pointer
                    QVariant
                    a0 =
                    qscriptvalue_cast<
                    QVariant
                        >(
                        context->argument(
                        0
                        )
                    );
                
                    // argument isCopyable or pointer
                    QVariant
                    a1 =
                    qscriptvalue_cast<
                    QVariant
                        >(
                        context->argument(
                        1
                        )
                    );
                
    // end of arguments

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        RS::
       compare(a0
        ,
    a1);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


        
    
    if( context->argumentCount() ==
    3 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNumber() || 
            context->argument(0).isString() || 
            context->argument(0).isBool() || 
            context->argument(0).isArray() || 
            context->argument(0).isNull() || 
            context->argument(0).isUndefined()
        ) /* type: QVariant */
     && (
            context->argument(1).isVariant() || 
            context->argument(1).isQObject() || 
            context->argument(1).isNumber() || 
            context->argument(1).isString() || 
            context->argument(1).isBool() || 
            context->argument(1).isArray() || 
            context->argument(1).isNull() || 
            context->argument(1).isUndefined()
        ) /* type: QVariant */
     && (
            context->argument(2).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable or pointer
                    QVariant
                    a0 =
                    qscriptvalue_cast<
                    QVariant
                        >(
                        context->argument(
                        0
                        )
                    );
                
                    // argument isCopyable or pointer
                    QVariant
                    a1 =
                    qscriptvalue_cast<
                    QVariant
                        >(
                        context->argument(
                        1
                        )
                    );
                
                    // argument isStandardType
                    bool
                    a2 =
                    (bool)
                    
                    context->argument( 2 ).
                    toBool();
                
    // end of arguments

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        RS::
       compare(a0
        ,
    a1
        ,
    a2);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        RS::
       compare(a0
        ,
    a1);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        RS::
       compare(a0
        ,
    a1
        ,
    a2);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'int'
    int cppResult =
        RS::
       getCpuCores();
        // return type: int
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'int'
    int cppResult =
        RS::
       getIdealThreadCount();
        // return type: int
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'QString'
    QString cppResult =
        RS::
       getBuildCpuArchitecture();
        // return type: QString
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'QString'
    QString cppResult =
        RS::
       getHostId();
        // return type: QString
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'QString'
    QString cppResult =
        RS::
       getSystemId();
        // return type: QString
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

    // call C++ function:
    // return type 'QString'
    QString cppResult =
        RS::
       getWindowManagerId();
        // return type: QString
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isString()
        ) /* type: QString */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    QString
                    a0 =
                    (QString)
                    
                    context->argument( 0 ).
                    toString();
                
    // end of arguments

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        RS::
       showInFileManager(a0);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isString()
        ) /* type: QString */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    QString
                    a0 =
                    (QString)
                    
                    context->argument( 0 ).
                    toString();
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isString()
        ) /* type: QString */
     && (
            context->argument(1).isString()
        ) /* type: QString */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    QString
                    a0 =
                    (QString)
                    
                    context->argument( 0 ).
                    toString();
                
                    // argument isStandardType
                    QString
                    a1 =
                    (QString)
                    
                    context->argument( 1 ).
                    toString();
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    0
    ){
    // prepare arguments:
    
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
    
    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 'QStringList'
    QStringList cppResult =
        RS::
       getPatternList(a0);
        // return type: QStringList
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
    
    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 'QStringList'
    QStringList cppResult =
        RS::
       getLinetypeList(a0);
        // return type: QStringList
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isArray()
        ) /* type: QStringList */
    
    ){
    // prepare arguments:
    
                    // argument isArray
                    QStringList
                    a0;
                    REcmaHelper::fromScriptValue(
                        engine,
                        context->argument(0),
                        a0
                    );
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isString()
        ) /* type: QString */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    QString
                    a0 =
                    (QString)
                    
                    context->argument( 0 ).
                    toString();
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isString()
        ) /* type: QString */
     && (
            context->argument(1).isString()
        ) /* type: QString */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    QString
                    a0 =
                    (QString)
                    
                    context->argument( 0 ).
                    toString();
                
                    // argument isStandardType
                    QString
                    a1 =
                    (QString)
                    
                    context->argument( 1 ).
                    toString();
                
    // end of arguments

    // call C++ function:
    // return type 'int'
    int cppResult =
        RS::
       compareAlphanumerical(a0
        ,
    a1);
        // return type: int
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isString()
        ) /* type: QString */
     && (
            context->argument(1).isString()
        ) /* type: QString */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    QString
                    a0 =
                    (QString)
                    
                    context->argument( 0 ).
                    toString();
                
                    // argument isStandardType
                    QString
                    a1 =
                    (QString)
                    
                    context->argument( 1 ).
                    toString();
                
    // end of arguments

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        RS::
       lessThanAlphanumerical(a0
        ,
    a1);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


        
            {
               return REcmaHelper::throwError("Wrong number/types of arguments for RS.lessThanAlphanumerical().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaS::lessThanAlphanumerical", context, engine);
            return result;
        }
         QScriptValue REcmaS::toString
    (QScriptContext *context, QScriptEngine *engine)
    
    {

    RS* self = getSelf("toString", context);
    
    QString result;
    
            result = QString("RS(0x%1)").arg((unsigned long int)self, 0, 16);
        
    return QScriptValue(result);
    }
     QScriptValue REcmaS::destroy(QScriptContext *context, QScriptEngine *engine)
    
    {

        RS* self = getSelf("RS", 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();
    }
    RS* REcmaS::getSelf(const QString& fName, QScriptContext* context)
    
        {
            RS* 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<RS >(context->thisObject())
                
                ;
            //}

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

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

            return self;
            


        }
         QScriptValue REcmaS::toScriptValueEnumMessageType(QScriptEngine* engine, const RS::MessageType& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumMessageType(const QScriptValue& value, RS::MessageType& out)
    
        {
            out = qvariant_cast<RS::MessageType>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumEntityType(QScriptEngine* engine, const RS::EntityType& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumEntityType(const QScriptValue& value, RS::EntityType& out)
    
        {
            out = qvariant_cast<RS::EntityType>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumProjectionRenderingHint(QScriptEngine* engine, const RS::ProjectionRenderingHint& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumProjectionRenderingHint(const QScriptValue& value, RS::ProjectionRenderingHint& out)
    
        {
            out = qvariant_cast<RS::ProjectionRenderingHint>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumOrthoMode(QScriptEngine* engine, const RS::OrthoMode& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumOrthoMode(const QScriptValue& value, RS::OrthoMode& out)
    
        {
            out = qvariant_cast<RS::OrthoMode>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumSide(QScriptEngine* engine, const RS::Side& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumSide(const QScriptValue& value, RS::Side& out)
    
        {
            out = qvariant_cast<RS::Side>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumEnding(QScriptEngine* engine, const RS::Ending& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumEnding(const QScriptValue& value, RS::Ending& out)
    
        {
            out = qvariant_cast<RS::Ending>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumVAlign(QScriptEngine* engine, const RS::VAlign& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumVAlign(const QScriptValue& value, RS::VAlign& out)
    
        {
            out = qvariant_cast<RS::VAlign>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumHAlign(QScriptEngine* engine, const RS::HAlign& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumHAlign(const QScriptValue& value, RS::HAlign& out)
    
        {
            out = qvariant_cast<RS::HAlign>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumTextDrawingDirection(QScriptEngine* engine, const RS::TextDrawingDirection& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumTextDrawingDirection(const QScriptValue& value, RS::TextDrawingDirection& out)
    
        {
            out = qvariant_cast<RS::TextDrawingDirection>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumTextLineSpacingStyle(QScriptEngine* engine, const RS::TextLineSpacingStyle& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumTextLineSpacingStyle(const QScriptValue& value, RS::TextLineSpacingStyle& out)
    
        {
            out = qvariant_cast<RS::TextLineSpacingStyle>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumFrom(QScriptEngine* engine, const RS::From& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumFrom(const QScriptValue& value, RS::From& out)
    
        {
            out = qvariant_cast<RS::From>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumIsoProjectionType(QScriptEngine* engine, const RS::IsoProjectionType& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumIsoProjectionType(const QScriptValue& value, RS::IsoProjectionType& out)
    
        {
            out = qvariant_cast<RS::IsoProjectionType>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumMeasurement(QScriptEngine* engine, const RS::Measurement& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumMeasurement(const QScriptValue& value, RS::Measurement& out)
    
        {
            out = qvariant_cast<RS::Measurement>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumUnit(QScriptEngine* engine, const RS::Unit& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumUnit(const QScriptValue& value, RS::Unit& out)
    
        {
            out = qvariant_cast<RS::Unit>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumAngleFormat(QScriptEngine* engine, const RS::AngleFormat& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumAngleFormat(const QScriptValue& value, RS::AngleFormat& out)
    
        {
            out = qvariant_cast<RS::AngleFormat>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumLinearFormat(QScriptEngine* engine, const RS::LinearFormat& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumLinearFormat(const QScriptValue& value, RS::LinearFormat& out)
    
        {
            out = qvariant_cast<RS::LinearFormat>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumAngleUnit(QScriptEngine* engine, const RS::AngleUnit& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumAngleUnit(const QScriptValue& value, RS::AngleUnit& out)
    
        {
            out = qvariant_cast<RS::AngleUnit>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumKnownVariable(QScriptEngine* engine, const RS::KnownVariable& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumKnownVariable(const QScriptValue& value, RS::KnownVariable& out)
    
        {
            out = qvariant_cast<RS::KnownVariable>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumBooleanOperation(QScriptEngine* engine, const RS::BooleanOperation& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumBooleanOperation(const QScriptValue& value, RS::BooleanOperation& out)
    
        {
            out = qvariant_cast<RS::BooleanOperation>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumFillType(QScriptEngine* engine, const RS::FillType& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumFillType(const QScriptValue& value, RS::FillType& out)
    
        {
            out = qvariant_cast<RS::FillType>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumOrientation(QScriptEngine* engine, const RS::Orientation& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumOrientation(const QScriptValue& value, RS::Orientation& out)
    
        {
            out = qvariant_cast<RS::Orientation>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumJoinType(QScriptEngine* engine, const RS::JoinType& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumJoinType(const QScriptValue& value, RS::JoinType& out)
    
        {
            out = qvariant_cast<RS::JoinType>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumEndType(QScriptEngine* engine, const RS::EndType& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumEndType(const QScriptValue& value, RS::EndType& out)
    
        {
            out = qvariant_cast<RS::EndType>(value.toVariant());
        }
         QScriptValue REcmaS::toScriptValueEnumEasing(QScriptEngine* engine, const RS::Easing& value)
    
        {
            return QScriptValue(engine, (int)value);
        }
         void REcmaS::fromScriptValueEnumEasing(const QScriptValue& value, RS::Easing& out)
    
        {
            out = qvariant_cast<RS::Easing>(value.toVariant());
        }
        