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

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

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

    
        // primary base class RNonCopyable:
        
            QScriptValue dpt = engine.defaultPrototype(
                qMetaTypeId<RNonCopyable*>());

            if (dpt.isValid()) {
                proto->setPrototype(dpt);
            }
          
        /*
        
        */
    

    QScriptValue fun;

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

    // destroy:
    REcmaHelper::registerFunction(&engine, proto, destroy, "destroy");
    
        // conversion for base class RRequireHeap
        REcmaHelper::registerFunction(&engine, proto, getRRequireHeap, "getRRequireHeap");
        

    // 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, setDocument, "setDocument");
            
            REcmaHelper::registerFunction(&engine, proto, getDocument, "getDocument");
            
            REcmaHelper::registerFunction(&engine, proto, clear, "clear");
            
            REcmaHelper::registerFunction(&engine, proto, beginTransaction, "beginTransaction");
            
            REcmaHelper::registerFunction(&engine, proto, commitTransaction, "commitTransaction");
            
            REcmaHelper::registerFunction(&engine, proto, rollbackTransaction, "rollbackTransaction");
            
            REcmaHelper::registerFunction(&engine, proto, orderBackToFront, "orderBackToFront");
            
            REcmaHelper::registerFunction(&engine, proto, sortBlocks, "sortBlocks");
            
            REcmaHelper::registerFunction(&engine, proto, sortLayers, "sortLayers");
            
            REcmaHelper::registerFunction(&engine, proto, queryAllObjects, "queryAllObjects");
            
            REcmaHelper::registerFunction(&engine, proto, queryAllVisibleEntities, "queryAllVisibleEntities");
            
            REcmaHelper::registerFunction(&engine, proto, queryAllEntities, "queryAllEntities");
            
            REcmaHelper::registerFunction(&engine, proto, queryWorkingSetEntities, "queryWorkingSetEntities");
            
            REcmaHelper::registerFunction(&engine, proto, queryAllUcs, "queryAllUcs");
            
            REcmaHelper::registerFunction(&engine, proto, queryAllLayers, "queryAllLayers");
            
            REcmaHelper::registerFunction(&engine, proto, queryAllLayerStates, "queryAllLayerStates");
            
            REcmaHelper::registerFunction(&engine, proto, queryAllBlocks, "queryAllBlocks");
            
            REcmaHelper::registerFunction(&engine, proto, queryAllLayoutBlocks, "queryAllLayoutBlocks");
            
            REcmaHelper::registerFunction(&engine, proto, queryAllLayouts, "queryAllLayouts");
            
            REcmaHelper::registerFunction(&engine, proto, queryAllViews, "queryAllViews");
            
            REcmaHelper::registerFunction(&engine, proto, queryAllLinetypes, "queryAllLinetypes");
            
            REcmaHelper::registerFunction(&engine, proto, queryLayerEntities, "queryLayerEntities");
            
            REcmaHelper::registerFunction(&engine, proto, querySelectedLayerEntities, "querySelectedLayerEntities");
            
            REcmaHelper::registerFunction(&engine, proto, hasBlockEntities, "hasBlockEntities");
            
            REcmaHelper::registerFunction(&engine, proto, queryBlockEntities, "queryBlockEntities");
            
            REcmaHelper::registerFunction(&engine, proto, queryLayerBlockEntities, "queryLayerBlockEntities");
            
            REcmaHelper::registerFunction(&engine, proto, queryChildEntities, "queryChildEntities");
            
            REcmaHelper::registerFunction(&engine, proto, hasChildEntities, "hasChildEntities");
            
            REcmaHelper::registerFunction(&engine, proto, queryBlockReferences, "queryBlockReferences");
            
            REcmaHelper::registerFunction(&engine, proto, queryAllBlockReferences, "queryAllBlockReferences");
            
            REcmaHelper::registerFunction(&engine, proto, queryAllViewports, "queryAllViewports");
            
            REcmaHelper::registerFunction(&engine, proto, querySelectedEntities, "querySelectedEntities");
            
            REcmaHelper::registerFunction(&engine, proto, querySelectedLayers, "querySelectedLayers");
            
            REcmaHelper::registerFunction(&engine, proto, queryInfiniteEntities, "queryInfiniteEntities");
            
            REcmaHelper::registerFunction(&engine, proto, queryDocumentVariables, "queryDocumentVariables");
            
            REcmaHelper::registerFunction(&engine, proto, queryDocumentVariablesDirect, "queryDocumentVariablesDirect");
            
            REcmaHelper::registerFunction(&engine, proto, queryObject, "queryObject");
            
            REcmaHelper::registerFunction(&engine, proto, queryObjectDirect, "queryObjectDirect");
            
            REcmaHelper::registerFunction(&engine, proto, queryObjectByHandle, "queryObjectByHandle");
            
            REcmaHelper::registerFunction(&engine, proto, queryEntity, "queryEntity");
            
            REcmaHelper::registerFunction(&engine, proto, queryEntityDirect, "queryEntityDirect");
            
            REcmaHelper::registerFunction(&engine, proto, queryVisibleEntityDirect, "queryVisibleEntityDirect");
            
            REcmaHelper::registerFunction(&engine, proto, queryUcs, "queryUcs");
            
            REcmaHelper::registerFunction(&engine, proto, queryUcsDirect, "queryUcsDirect");
            
            REcmaHelper::registerFunction(&engine, proto, queryLayer, "queryLayer");
            
            REcmaHelper::registerFunction(&engine, proto, queryLayerDirect, "queryLayerDirect");
            
            REcmaHelper::registerFunction(&engine, proto, queryCurrentLayer, "queryCurrentLayer");
            
            REcmaHelper::registerFunction(&engine, proto, queryLayerState, "queryLayerState");
            
            REcmaHelper::registerFunction(&engine, proto, queryLayerStateDirect, "queryLayerStateDirect");
            
            REcmaHelper::registerFunction(&engine, proto, queryLayout, "queryLayout");
            
            REcmaHelper::registerFunction(&engine, proto, queryLayoutDirect, "queryLayoutDirect");
            
            REcmaHelper::registerFunction(&engine, proto, queryCurrentView, "queryCurrentView");
            
            REcmaHelper::registerFunction(&engine, proto, queryLinetypeDirect, "queryLinetypeDirect");
            
            REcmaHelper::registerFunction(&engine, proto, queryLinetype, "queryLinetype");
            
            REcmaHelper::registerFunction(&engine, proto, queryBlockDirect, "queryBlockDirect");
            
            REcmaHelper::registerFunction(&engine, proto, queryBlock, "queryBlock");
            
            REcmaHelper::registerFunction(&engine, proto, queryView, "queryView");
            
            REcmaHelper::registerFunction(&engine, proto, setCurrentLayer, "setCurrentLayer");
            
            REcmaHelper::registerFunction(&engine, proto, getCurrentLayerId, "getCurrentLayerId");
            
            REcmaHelper::registerFunction(&engine, proto, getCurrentViewId, "getCurrentViewId");
            
            REcmaHelper::registerFunction(&engine, proto, setCurrentColor, "setCurrentColor");
            
            REcmaHelper::registerFunction(&engine, proto, getCurrentColor, "getCurrentColor");
            
            REcmaHelper::registerFunction(&engine, proto, setCurrentLineweight, "setCurrentLineweight");
            
            REcmaHelper::registerFunction(&engine, proto, getCurrentLineweight, "getCurrentLineweight");
            
            REcmaHelper::registerFunction(&engine, proto, setCurrentLinetype, "setCurrentLinetype");
            
            REcmaHelper::registerFunction(&engine, proto, setCurrentLinetypePattern, "setCurrentLinetypePattern");
            
            REcmaHelper::registerFunction(&engine, proto, getCurrentLinetypeId, "getCurrentLinetypeId");
            
            REcmaHelper::registerFunction(&engine, proto, getCurrentLinetypePattern, "getCurrentLinetypePattern");
            
            REcmaHelper::registerFunction(&engine, proto, queryCurrentLinetype, "queryCurrentLinetype");
            
            REcmaHelper::registerFunction(&engine, proto, queryCurrentBlock, "queryCurrentBlock");
            
            REcmaHelper::registerFunction(&engine, proto, setCurrentBlock, "setCurrentBlock");
            
            REcmaHelper::registerFunction(&engine, proto, getCurrentBlockId, "getCurrentBlockId");
            
            REcmaHelper::registerFunction(&engine, proto, setCurrentViewport, "setCurrentViewport");
            
            REcmaHelper::registerFunction(&engine, proto, unsetCurrentViewport, "unsetCurrentViewport");
            
            REcmaHelper::registerFunction(&engine, proto, getCurrentViewportId, "getCurrentViewportId");
            
            REcmaHelper::registerFunction(&engine, proto, setModelSpaceBlockId, "setModelSpaceBlockId");
            
            REcmaHelper::registerFunction(&engine, proto, getModelSpaceBlockId, "getModelSpaceBlockId");
            
            REcmaHelper::registerFunction(&engine, proto, setCurrentView, "setCurrentView");
            
            REcmaHelper::registerFunction(&engine, proto, startDocumentVariablesTransaction, "startDocumentVariablesTransaction");
            
            REcmaHelper::registerFunction(&engine, proto, endDocumentVariablesTransaction, "endDocumentVariablesTransaction");
            
            REcmaHelper::registerFunction(&engine, proto, setUnit, "setUnit");
            
            REcmaHelper::registerFunction(&engine, proto, getUnit, "getUnit");
            
            REcmaHelper::registerFunction(&engine, proto, setMeasurement, "setMeasurement");
            
            REcmaHelper::registerFunction(&engine, proto, getMeasurement, "getMeasurement");
            
            REcmaHelper::registerFunction(&engine, proto, setDimensionFont, "setDimensionFont");
            
            REcmaHelper::registerFunction(&engine, proto, getDimensionFont, "getDimensionFont");
            
            REcmaHelper::registerFunction(&engine, proto, setLinetypeScale, "setLinetypeScale");
            
            REcmaHelper::registerFunction(&engine, proto, getLinetypeScale, "getLinetypeScale");
            
            REcmaHelper::registerFunction(&engine, proto, getBlockName, "getBlockName");
            
            REcmaHelper::registerFunction(&engine, proto, getBlockNameFromLayout, "getBlockNameFromLayout");
            
            REcmaHelper::registerFunction(&engine, proto, getBlockNames, "getBlockNames");
            
            REcmaHelper::registerFunction(&engine, proto, getBlockId, "getBlockId");
            
            REcmaHelper::registerFunction(&engine, proto, getBlockIdAuto, "getBlockIdAuto");
            
            REcmaHelper::registerFunction(&engine, proto, hasBlock, "hasBlock");
            
            REcmaHelper::registerFunction(&engine, proto, getViewName, "getViewName");
            
            REcmaHelper::registerFunction(&engine, proto, getViewNames, "getViewNames");
            
            REcmaHelper::registerFunction(&engine, proto, getViewId, "getViewId");
            
            REcmaHelper::registerFunction(&engine, proto, hasView, "hasView");
            
            REcmaHelper::registerFunction(&engine, proto, getLayerName, "getLayerName");
            
            REcmaHelper::registerFunction(&engine, proto, getLayerNames, "getLayerNames");
            
            REcmaHelper::registerFunction(&engine, proto, getLayerId, "getLayerId");
            
            REcmaHelper::registerFunction(&engine, proto, setLayer0Id, "setLayer0Id");
            
            REcmaHelper::registerFunction(&engine, proto, getLayer0Id, "getLayer0Id");
            
            REcmaHelper::registerFunction(&engine, proto, hasLayer, "hasLayer");
            
            REcmaHelper::registerFunction(&engine, proto, getLayerStateName, "getLayerStateName");
            
            REcmaHelper::registerFunction(&engine, proto, getLayerStateNames, "getLayerStateNames");
            
            REcmaHelper::registerFunction(&engine, proto, getLayerStateId, "getLayerStateId");
            
            REcmaHelper::registerFunction(&engine, proto, hasLayerStates, "hasLayerStates");
            
            REcmaHelper::registerFunction(&engine, proto, hasLayerState, "hasLayerState");
            
            REcmaHelper::registerFunction(&engine, proto, getLayoutName, "getLayoutName");
            
            REcmaHelper::registerFunction(&engine, proto, getLayoutNames, "getLayoutNames");
            
            REcmaHelper::registerFunction(&engine, proto, getLayoutId, "getLayoutId");
            
            REcmaHelper::registerFunction(&engine, proto, hasLayout, "hasLayout");
            
            REcmaHelper::registerFunction(&engine, proto, getLinetypeName, "getLinetypeName");
            
            REcmaHelper::registerFunction(&engine, proto, getLinetypeDescription, "getLinetypeDescription");
            
            REcmaHelper::registerFunction(&engine, proto, getLinetypeLabel, "getLinetypeLabel");
            
            REcmaHelper::registerFunction(&engine, proto, getLinetypeNames, "getLinetypeNames");
            
            REcmaHelper::registerFunction(&engine, proto, getLinetypePatterns, "getLinetypePatterns");
            
            REcmaHelper::registerFunction(&engine, proto, getLinetypeId, "getLinetypeId");
            
            REcmaHelper::registerFunction(&engine, proto, hasLinetype, "hasLinetype");
            
            REcmaHelper::registerFunction(&engine, proto, getVariables, "getVariables");
            
            REcmaHelper::registerFunction(&engine, proto, setVariable, "setVariable");
            
            REcmaHelper::registerFunction(&engine, proto, removeVariable, "removeVariable");
            
            REcmaHelper::registerFunction(&engine, proto, getVariable, "getVariable");
            
            REcmaHelper::registerFunction(&engine, proto, hasVariable, "hasVariable");
            
            REcmaHelper::registerFunction(&engine, proto, setKnownVariable, "setKnownVariable");
            
            REcmaHelper::registerFunction(&engine, proto, getKnownVariable, "getKnownVariable");
            
            REcmaHelper::registerFunction(&engine, proto, countSelectedEntities, "countSelectedEntities");
            
            REcmaHelper::registerFunction(&engine, proto, clearEntitySelection, "clearEntitySelection");
            
            REcmaHelper::registerFunction(&engine, proto, selectAllEntities, "selectAllEntities");
            
            REcmaHelper::registerFunction(&engine, proto, selectEntity, "selectEntity");
            
            REcmaHelper::registerFunction(&engine, proto, selectEntities, "selectEntities");
            
            REcmaHelper::registerFunction(&engine, proto, deselectEntity, "deselectEntity");
            
            REcmaHelper::registerFunction(&engine, proto, deselectEntities, "deselectEntities");
            
            REcmaHelper::registerFunction(&engine, proto, isSelected, "isSelected");
            
            REcmaHelper::registerFunction(&engine, proto, isSelectedWorkingSet, "isSelectedWorkingSet");
            
            REcmaHelper::registerFunction(&engine, proto, isEntity, "isEntity");
            
            REcmaHelper::registerFunction(&engine, proto, isLayerLocked, "isLayerLocked");
            
            REcmaHelper::registerFunction(&engine, proto, isParentLayerLocked, "isParentLayerLocked");
            
            REcmaHelper::registerFunction(&engine, proto, isLayerOff, "isLayerOff");
            
            REcmaHelper::registerFunction(&engine, proto, isLayerOffOrFrozen, "isLayerOffOrFrozen");
            
            REcmaHelper::registerFunction(&engine, proto, isLayerFrozen, "isLayerFrozen");
            
            REcmaHelper::registerFunction(&engine, proto, isParentLayerFrozen, "isParentLayerFrozen");
            
            REcmaHelper::registerFunction(&engine, proto, isLayerSnappable, "isLayerSnappable");
            
            REcmaHelper::registerFunction(&engine, proto, isParentLayerSnappable, "isParentLayerSnappable");
            
            REcmaHelper::registerFunction(&engine, proto, isLayerPlottable, "isLayerPlottable");
            
            REcmaHelper::registerFunction(&engine, proto, isParentLayerPlottable, "isParentLayerPlottable");
            
            REcmaHelper::registerFunction(&engine, proto, isEntityVisible, "isEntityVisible");
            
            REcmaHelper::registerFunction(&engine, proto, isBlockFrozen, "isBlockFrozen");
            
            REcmaHelper::registerFunction(&engine, proto, isLayoutBlock, "isLayoutBlock");
            
            REcmaHelper::registerFunction(&engine, proto, setObjectId, "setObjectId");
            
            REcmaHelper::registerFunction(&engine, proto, setObjectHandle, "setObjectHandle");
            
            REcmaHelper::registerFunction(&engine, proto, setEntityParentId, "setEntityParentId");
            
            REcmaHelper::registerFunction(&engine, proto, setUndoStatus, "setUndoStatus");
            
            REcmaHelper::registerFunction(&engine, proto, hasSelection, "hasSelection");
            
            REcmaHelper::registerFunction(&engine, proto, getBoundingBox, "getBoundingBox");
            
            REcmaHelper::registerFunction(&engine, proto, getSelectionBox, "getSelectionBox");
            
            REcmaHelper::registerFunction(&engine, proto, getEntitiesBox, "getEntitiesBox");
            
            REcmaHelper::registerFunction(&engine, proto, removeObject, "removeObject");
            
            REcmaHelper::registerFunction(&engine, proto, saveObject, "saveObject");
            
            REcmaHelper::registerFunction(&engine, proto, deleteObject, "deleteObject");
            
            REcmaHelper::registerFunction(&engine, proto, getLastTransactionId, "getLastTransactionId");
            
            REcmaHelper::registerFunction(&engine, proto, setLastTransactionId, "setLastTransactionId");
            
            REcmaHelper::registerFunction(&engine, proto, startTransactionGroup, "startTransactionGroup");
            
            REcmaHelper::registerFunction(&engine, proto, getTransactionGroup, "getTransactionGroup");
            
            REcmaHelper::registerFunction(&engine, proto, saveTransaction, "saveTransaction");
            
            REcmaHelper::registerFunction(&engine, proto, deleteTransactionsFrom, "deleteTransactionsFrom");
            
            REcmaHelper::registerFunction(&engine, proto, resetTransactionStack, "resetTransactionStack");
            
            REcmaHelper::registerFunction(&engine, proto, getTransaction, "getTransaction");
            
            REcmaHelper::registerFunction(&engine, proto, toggleUndoStatus, "toggleUndoStatus");
            
            REcmaHelper::registerFunction(&engine, proto, getMaxTransactionId, "getMaxTransactionId");
            
            REcmaHelper::registerFunction(&engine, proto, getMaxLineweight, "getMaxLineweight");
            
            REcmaHelper::registerFunction(&engine, proto, getNewObjectId, "getNewObjectId");
            
            REcmaHelper::registerFunction(&engine, proto, getMaxObjectId, "getMaxObjectId");
            
            REcmaHelper::registerFunction(&engine, proto, getNewObjectHandle, "getNewObjectHandle");
            
            REcmaHelper::registerFunction(&engine, proto, getMaxObjectHandle, "getMaxObjectHandle");
            
            REcmaHelper::registerFunction(&engine, proto, setMaxDrawOrder, "setMaxDrawOrder");
            
            REcmaHelper::registerFunction(&engine, proto, getMaxDrawOrder, "getMaxDrawOrder");
            
            REcmaHelper::registerFunction(&engine, proto, getMinDrawOrder, "getMinDrawOrder");
            
            REcmaHelper::registerFunction(&engine, proto, isInBackStorage, "isInBackStorage");
            
            REcmaHelper::registerFunction(&engine, proto, setModified, "setModified");
            
            REcmaHelper::registerFunction(&engine, proto, isModified, "isModified");
            
            REcmaHelper::registerFunction(&engine, proto, getLastModified, "getLastModified");
            
            REcmaHelper::registerFunction(&engine, proto, addModifiedListener, "addModifiedListener");
            
            REcmaHelper::registerFunction(&engine, proto, update, "update");
            
        engine.setDefaultPrototype(
            qMetaTypeId<RStorage*>(), *proto);

        
    

    QScriptValue ctor = engine.newFunction(createEcma, *proto, 2);
    
    // static methods:
    
            REcmaHelper::registerFunction(&engine, &ctor, getKnownVariableName, "getKnownVariableName");
            

    // static properties:
    

    // enum values:
    

    // enum conversions:
    
        
    // init class:
    engine.globalObject().setProperty("RStorage",
    ctor, QScriptValue::SkipInEnumeration);
    
    if( protoCreated ){
       delete proto;
    }
    
    }
     QScriptValue REcmaStorage::createEcma(QScriptContext* context, QScriptEngine* engine) 
    
    {
           return REcmaHelper::throwError("Abstract class RStorage: Cannot be constructed.",
               context); 
    }
    

    // conversion functions for base classes:
     QScriptValue REcmaStorage::getRRequireHeap(QScriptContext *context,
            QScriptEngine *engine)
        
            {
                RRequireHeap* cppResult =
                    qscriptvalue_cast<RStorage*> (context->thisObject());
                QScriptValue result = qScriptValueFromValue(engine, cppResult);
                return result;
            }
            

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

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

        return qScriptValueFromSequence(engine, list);
    }
    

    // properties:
    

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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("setDocument", 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: RDocument * */
    
    ){
    // prepare arguments:
    
                    // argument is pointer
                    RDocument * a0 = NULL;

                    a0 = 
                        REcmaHelper::scriptValueTo<RDocument >(
                            context->argument(0)
                        );
                    
                    if (a0==NULL && 
                        !context->argument(0).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 0 is not of type RDocument *RDocument *.", context);                    
                    }
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* 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 RStorage.getDocument().",
                   context);
            }
            //REcmaHelper::functionEnd("REcmaStorage::getDocument", context, engine);
            return result;
        }
         QScriptValue
        REcmaStorage::clear
        (QScriptContext* context, QScriptEngine* engine) 
        
        {
            //REcmaHelper::functionStart("REcmaStorage::clear", context, engine);
            //qDebug() << "ECMAScript WRAPPER: REcmaStorage::clear";
            //QCoreApplication::processEvents();

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("clear", 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->clear();
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("beginTransaction", 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->beginTransaction();
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("commitTransaction", 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->commitTransaction();
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("rollbackTransaction", 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->rollbackTransaction();
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isArray()
        ) /* type: QSet < REntity::Id > */
    
    ){
    // prepare arguments:
    
                    // argument isArray
                    QSet < REntity::Id >
                    a0;
                    REcmaHelper::fromScriptValue(
                        engine,
                        context->argument(0),
                        a0
                    );
                
    // end of arguments

    // call C++ function:
    // return type 'QList < REntity::Id >'
    QList < REntity::Id > cppResult =
        
               self->orderBackToFront(a0);
        // return type: QList < REntity::Id >
                // List of ...:
                result = REcmaHelper::listToScriptValue(engine, cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isArray()
        ) /* type: QList < RBlock::Id > */
    
    ){
    // prepare arguments:
    
                    // argument isArray
                    QList < RBlock::Id >
                    a0;
                    REcmaHelper::fromScriptValue(
                        engine,
                        context->argument(0),
                        a0
                    );
                
    // end of arguments

    // call C++ function:
    // return type 'QList < RBlock::Id >'
    QList < RBlock::Id > cppResult =
        
               self->sortBlocks(a0);
        // return type: QList < RBlock::Id >
                // List of ...:
                result = REcmaHelper::listToScriptValue(engine, cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isArray()
        ) /* type: QList < RLayer::Id > */
    
    ){
    // prepare arguments:
    
                    // argument isArray
                    QList < RLayer::Id >
                    a0;
                    REcmaHelper::fromScriptValue(
                        engine,
                        context->argument(0),
                        a0
                    );
                
    // end of arguments

    // call C++ function:
    // return type 'QList < RLayer::Id >'
    QList < RLayer::Id > cppResult =
        
               self->sortLayers(a0);
        // return type: QList < RLayer::Id >
                // List of ...:
                result = REcmaHelper::listToScriptValue(engine, cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryAllObjects", 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 'QSet < RObject::Id >'
    QSet < RObject::Id > cppResult =
        
               self->queryAllObjects();
        // return type: QSet < RObject::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryAllVisibleEntities", 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 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryAllVisibleEntities();
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryAllEntities", 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 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryAllEntities();
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    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 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryAllEntities(a0);
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isBool()
        ) /* type: bool */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    bool
                    a0 =
                    (bool)
                    
                    context->argument( 0 ).
                    toBool();
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
    // end of arguments

    // call C++ function:
    // return type 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryAllEntities(a0
        ,
    a1);
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    if( context->argumentCount() ==
    3 && (
            context->argument(0).isBool()
        ) /* type: bool */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
     && (
            context->argument(2).isNumber()
        ) /* type: RS::EntityType */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    bool
                    a0 =
                    (bool)
                    
                    context->argument( 0 ).
                    toBool();
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
                    // argument isStandardType
                    RS::EntityType
                    a2 =
                    (RS::EntityType)
                    (int)
                    context->argument( 2 ).
                    toNumber();
                
    // end of arguments

    // call C++ function:
    // return type 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryAllEntities(a0
        ,
    a1
        ,
    a2);
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    if( context->argumentCount() ==
    3 && (
            context->argument(0).isBool()
        ) /* type: bool */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
     && (
            context->argument(2).isArray()
        ) /* type: QList < RS::EntityType > */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    bool
                    a0 =
                    (bool)
                    
                    context->argument( 0 ).
                    toBool();
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
                    // argument isArray
                    QList < RS::EntityType >
                    a2;
                    REcmaHelper::fromScriptValue(
                        engine,
                        context->argument(2),
                        a2
                    );
                
    // end of arguments

    // call C++ function:
    // return type 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryAllEntities(a0
        ,
    a1
        ,
    a2);
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryWorkingSetEntities", 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 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryWorkingSetEntities();
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryAllUcs", 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 'QSet < RUcs::Id >'
    QSet < RUcs::Id > cppResult =
        
               self->queryAllUcs();
        // return type: QSet < RUcs::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryAllLayers", 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 'QSet < RLayer::Id >'
    QSet < RLayer::Id > cppResult =
        
               self->queryAllLayers();
        // return type: QSet < RLayer::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    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 'QSet < RLayer::Id >'
    QSet < RLayer::Id > cppResult =
        
               self->queryAllLayers(a0);
        // return type: QSet < RLayer::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryAllLayerStates", 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 'QSet < RLayerState::Id >'
    QSet < RLayerState::Id > cppResult =
        
               self->queryAllLayerStates();
        // return type: QSet < RLayerState::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    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 'QSet < RLayerState::Id >'
    QSet < RLayerState::Id > cppResult =
        
               self->queryAllLayerStates(a0);
        // return type: QSet < RLayerState::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryAllBlocks", 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 'QSet < RBlock::Id >'
    QSet < RBlock::Id > cppResult =
        
               self->queryAllBlocks();
        // return type: QSet < RBlock::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    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 'QSet < RBlock::Id >'
    QSet < RBlock::Id > cppResult =
        
               self->queryAllBlocks(a0);
        // return type: QSet < RBlock::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryAllLayoutBlocks", 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 'QSet < RBlock::Id >'
    QSet < RBlock::Id > cppResult =
        
               self->queryAllLayoutBlocks();
        // return type: QSet < RBlock::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    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 'QSet < RBlock::Id >'
    QSet < RBlock::Id > cppResult =
        
               self->queryAllLayoutBlocks(a0);
        // return type: QSet < RBlock::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isBool()
        ) /* type: bool */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    bool
                    a0 =
                    (bool)
                    
                    context->argument( 0 ).
                    toBool();
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
    // end of arguments

    // call C++ function:
    // return type 'QSet < RBlock::Id >'
    QSet < RBlock::Id > cppResult =
        
               self->queryAllLayoutBlocks(a0
        ,
    a1);
        // return type: QSet < RBlock::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryAllLayouts", 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 'QSet < RLayout::Id >'
    QSet < RLayout::Id > cppResult =
        
               self->queryAllLayouts();
        // return type: QSet < RLayout::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    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 'QSet < RLayout::Id >'
    QSet < RLayout::Id > cppResult =
        
               self->queryAllLayouts(a0);
        // return type: QSet < RLayout::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryAllViews", 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 'QSet < RView::Id >'
    QSet < RView::Id > cppResult =
        
               self->queryAllViews();
        // return type: QSet < RView::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    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 'QSet < RView::Id >'
    QSet < RView::Id > cppResult =
        
               self->queryAllViews(a0);
        // return type: QSet < RView::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryAllLinetypes", 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 'QSet < RLinetype::Id >'
    QSet < RLinetype::Id > cppResult =
        
               self->queryAllLinetypes();
        // return type: QSet < RLinetype::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

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

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

    // call C++ function:
    // return type 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryLayerEntities(a0);
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isNumber()
        ) /* type: RLayer::Id */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    RLayer::Id
                    a0 =
                    (RLayer::Id)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
    // end of arguments

    // call C++ function:
    // return type 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryLayerEntities(a0
        ,
    a1);
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

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

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

    // call C++ function:
    // return type 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->querySelectedLayerEntities(a0);
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isNumber()
        ) /* type: RLayer::Id */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    RLayer::Id
                    a0 =
                    (RLayer::Id)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
    // end of arguments

    // call C++ function:
    // return type 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->querySelectedLayerEntities(a0
        ,
    a1);
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

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

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

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


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

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

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

    // call C++ function:
    // return type 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryBlockEntities(a0);
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isNumber()
        ) /* type: RLayer::Id */
     && (
            context->argument(1).isNumber()
        ) /* type: RBlock::Id */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    RLayer::Id
                    a0 =
                    (RLayer::Id)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
                    // argument isStandardType
                    RBlock::Id
                    a1 =
                    (RBlock::Id)
                    (int)
                    context->argument( 1 ).
                    toNumber();
                
    // end of arguments

    // call C++ function:
    // return type 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryLayerBlockEntities(a0
        ,
    a1);
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

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

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

    // call C++ function:
    // return type 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryChildEntities(a0);
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isNumber()
        ) /* type: REntity::Id */
     && (
            context->argument(1).isNumber()
        ) /* type: RS::EntityType */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    REntity::Id
                    a0 =
                    (REntity::Id)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
                    // argument isStandardType
                    RS::EntityType
                    a1 =
                    (RS::EntityType)
                    (int)
                    context->argument( 1 ).
                    toNumber();
                
    // end of arguments

    // call C++ function:
    // return type 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryChildEntities(a0
        ,
    a1);
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

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

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

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


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

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

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

    // call C++ function:
    // return type 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryBlockReferences(a0);
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryAllBlockReferences", 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 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryAllBlockReferences();
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryAllViewports", 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 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryAllViewports();
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("querySelectedEntities", 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 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->querySelectedEntities();
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("querySelectedLayers", 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 'QSet < RObject::Id >'
    QSet < RObject::Id > cppResult =
        
               self->querySelectedLayers();
        // return type: QSet < RObject::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryInfiniteEntities", 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 'QSet < REntity::Id >'
    QSet < REntity::Id > cppResult =
        
               self->queryInfiniteEntities();
        // return type: QSet < REntity::Id >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryDocumentVariables", 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 'QSharedPointer < RDocumentVariables >'
    QSharedPointer < RDocumentVariables > cppResult =
        
               self->queryDocumentVariables();
        // return type: QSharedPointer < RDocumentVariables >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryDocumentVariablesDirect", 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 'QSharedPointer < RDocumentVariables >'
    QSharedPointer < RDocumentVariables > cppResult =
        
               self->queryDocumentVariablesDirect();
        // return type: QSharedPointer < RDocumentVariables >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RObject >'
    QSharedPointer < RObject > cppResult =
        
               self->queryObject(a0);
        // return type: QSharedPointer < RObject >
                // Shared pointer to object, cast to best match:
                result = REcmaHelper::toScriptValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RObject >'
    QSharedPointer < RObject > cppResult =
        
               self->queryObjectDirect(a0);
        // return type: QSharedPointer < RObject >
                // Shared pointer to object, cast to best match:
                result = REcmaHelper::toScriptValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RObject >'
    QSharedPointer < RObject > cppResult =
        
               self->queryObjectByHandle(a0);
        // return type: QSharedPointer < RObject >
                // Shared pointer to object, cast to best match:
                result = REcmaHelper::toScriptValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < REntity >'
    QSharedPointer < REntity > cppResult =
        
               self->queryEntity(a0);
        // return type: QSharedPointer < REntity >
                // Shared pointer to entity, cast to best match:
                result = REcmaHelper::toScriptValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < REntity >'
    QSharedPointer < REntity > cppResult =
        
               self->queryEntityDirect(a0);
        // return type: QSharedPointer < REntity >
                // Shared pointer to entity, cast to best match:
                result = REcmaHelper::toScriptValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < REntity >'
    QSharedPointer < REntity > cppResult =
        
               self->queryVisibleEntityDirect(a0);
        // return type: QSharedPointer < REntity >
                // Shared pointer to entity, cast to best match:
                result = REcmaHelper::toScriptValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RUcs >'
    QSharedPointer < RUcs > cppResult =
        
               self->queryUcs(a0);
        // return type: QSharedPointer < RUcs >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    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 'QSharedPointer < RUcs >'
    QSharedPointer < RUcs > cppResult =
        
               self->queryUcs(a0);
        // return type: QSharedPointer < RUcs >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RUcs >'
    QSharedPointer < RUcs > cppResult =
        
               self->queryUcsDirect(a0);
        // return type: QSharedPointer < RUcs >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RLayer >'
    QSharedPointer < RLayer > cppResult =
        
               self->queryLayer(a0);
        // return type: QSharedPointer < RLayer >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    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 'QSharedPointer < RLayer >'
    QSharedPointer < RLayer > cppResult =
        
               self->queryLayer(a0);
        // return type: QSharedPointer < RLayer >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RLayer >'
    QSharedPointer < RLayer > cppResult =
        
               self->queryLayerDirect(a0);
        // return type: QSharedPointer < RLayer >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    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 'QSharedPointer < RLayer >'
    QSharedPointer < RLayer > cppResult =
        
               self->queryLayerDirect(a0);
        // return type: QSharedPointer < RLayer >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryCurrentLayer", 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 'QSharedPointer < RLayer >'
    QSharedPointer < RLayer > cppResult =
        
               self->queryCurrentLayer();
        // return type: QSharedPointer < RLayer >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RLayerState >'
    QSharedPointer < RLayerState > cppResult =
        
               self->queryLayerState(a0);
        // return type: QSharedPointer < RLayerState >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    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 'QSharedPointer < RLayerState >'
    QSharedPointer < RLayerState > cppResult =
        
               self->queryLayerState(a0);
        // return type: QSharedPointer < RLayerState >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RLayerState >'
    QSharedPointer < RLayerState > cppResult =
        
               self->queryLayerStateDirect(a0);
        // return type: QSharedPointer < RLayerState >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    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 'QSharedPointer < RLayerState >'
    QSharedPointer < RLayerState > cppResult =
        
               self->queryLayerStateDirect(a0);
        // return type: QSharedPointer < RLayerState >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RLayout >'
    QSharedPointer < RLayout > cppResult =
        
               self->queryLayout(a0);
        // return type: QSharedPointer < RLayout >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    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 'QSharedPointer < RLayout >'
    QSharedPointer < RLayout > cppResult =
        
               self->queryLayout(a0);
        // return type: QSharedPointer < RLayout >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RLayout >'
    QSharedPointer < RLayout > cppResult =
        
               self->queryLayoutDirect(a0);
        // return type: QSharedPointer < RLayout >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryCurrentView", 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 'QSharedPointer < RView >'
    QSharedPointer < RView > cppResult =
        
               self->queryCurrentView();
        // return type: QSharedPointer < RView >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RLinetype >'
    QSharedPointer < RLinetype > cppResult =
        
               self->queryLinetypeDirect(a0);
        // return type: QSharedPointer < RLinetype >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RLinetype >'
    QSharedPointer < RLinetype > cppResult =
        
               self->queryLinetype(a0);
        // return type: QSharedPointer < RLinetype >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    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 'QSharedPointer < RLinetype >'
    QSharedPointer < RLinetype > cppResult =
        
               self->queryLinetype(a0);
        // return type: QSharedPointer < RLinetype >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 'QSharedPointer < RBlock >'
    QSharedPointer < RBlock > cppResult =
        
               self->queryBlockDirect(a0);
        // return type: QSharedPointer < RBlock >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isNumber()
        ) /* type: RBlock::Id */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    RBlock::Id
                    a0 =
                    (RBlock::Id)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
    // end of arguments

    // call C++ function:
    // return type 'QSharedPointer < RBlock >'
    QSharedPointer < RBlock > cppResult =
        
               self->queryBlockDirect(a0);
        // return type: QSharedPointer < RBlock >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RBlock >'
    QSharedPointer < RBlock > cppResult =
        
               self->queryBlock(a0);
        // return type: QSharedPointer < RBlock >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    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 'QSharedPointer < RBlock >'
    QSharedPointer < RBlock > cppResult =
        
               self->queryBlock(a0);
        // return type: QSharedPointer < RBlock >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

    // call C++ function:
    // return type 'QSharedPointer < RView >'
    QSharedPointer < RView > cppResult =
        
               self->queryView(a0);
        // return type: QSharedPointer < RView >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    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 'QSharedPointer < RView >'
    QSharedPointer < RView > cppResult =
        
               self->queryView(a0);
        // return type: QSharedPointer < RView >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

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


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isNumber()
        ) /* type: RLayer::Id */
     && (
            context->argument(1).isVariant() || 
            context->argument(1).isQObject() || 
            context->argument(1).isNull()
        ) /* type: RTransaction * */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    RLayer::Id
                    a0 =
                    (RLayer::Id)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
                    // argument is pointer
                    RTransaction * a1 = NULL;

                    a1 = 
                        REcmaHelper::scriptValueTo<RTransaction >(
                            context->argument(1)
                        );
                    
                    if (a1==NULL && 
                        !context->argument(1).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 1 is not of type RTransaction *RTransaction *.", context);                    
                    }
                
    // end of arguments

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


        
    
    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 'void'
    
               self->setCurrentLayer(a0);
    } else


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isString()
        ) /* type: QString */
     && (
            context->argument(1).isVariant() || 
            context->argument(1).isQObject() || 
            context->argument(1).isNull()
        ) /* type: RTransaction * */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    QString
                    a0 =
                    (QString)
                    
                    context->argument( 0 ).
                    toString();
                
                    // argument is pointer
                    RTransaction * a1 = NULL;

                    a1 = 
                        REcmaHelper::scriptValueTo<RTransaction >(
                            context->argument(1)
                        );
                    
                    if (a1==NULL && 
                        !context->argument(1).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 1 is not of type RTransaction *RTransaction *.", context);                    
                    }
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getCurrentLayerId", 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 'RLayer::Id'
    RLayer::Id cppResult =
        
               self->getCurrentLayerId();
        // return type: RLayer::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getCurrentViewId", 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 'RView::Id'
    RView::Id cppResult =
        
               self->getCurrentViewId();
        // return type: RView::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("setCurrentColor", 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: RColor */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RColor*
                    ap0 =
                    qscriptvalue_cast<
                    RColor*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RStorage: Argument 0 is not of type RColor.",
                               context);                    
                    }
                    RColor 
                    a0 = 
                    *ap0;
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getCurrentColor", 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 'RColor'
    RColor cppResult =
        
               self->getCurrentColor();
        // return type: RColor
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getCurrentLineweight", 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 'RLineweight::Lineweight'
    RLineweight::Lineweight cppResult =
        
               self->getCurrentLineweight();
        // return type: RLineweight::Lineweight
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


        
    
    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 'void'
    
               self->setCurrentLinetype(a0);
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("setCurrentLinetypePattern", 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: RLinetypePattern */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RLinetypePattern*
                    ap0 =
                    qscriptvalue_cast<
                    RLinetypePattern*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RStorage: Argument 0 is not of type RLinetypePattern.",
                               context);                    
                    }
                    RLinetypePattern 
                    a0 = 
                    *ap0;
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getCurrentLinetypeId", 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 'RLinetype::Id'
    RLinetype::Id cppResult =
        
               self->getCurrentLinetypeId();
        // return type: RLinetype::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getCurrentLinetypePattern", 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 'RLinetypePattern'
    RLinetypePattern cppResult =
        
               self->getCurrentLinetypePattern();
        // return type: RLinetypePattern
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryCurrentLinetype", 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 'QSharedPointer < RLinetype >'
    QSharedPointer < RLinetype > cppResult =
        
               self->queryCurrentLinetype();
        // return type: QSharedPointer < RLinetype >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("queryCurrentBlock", 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 'QSharedPointer < RBlock >'
    QSharedPointer < RBlock > cppResult =
        
               self->queryCurrentBlock();
        // return type: QSharedPointer < RBlock >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

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

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


        
    
    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 'void'
    
               self->setCurrentBlock(a0);
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getCurrentBlockId", 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 'RBlock::Id'
    RBlock::Id cppResult =
        
               self->getCurrentBlockId();
        // return type: RBlock::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("unsetCurrentViewport", 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->unsetCurrentViewport();
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getCurrentViewportId", 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 'RObject::Id'
    RObject::Id cppResult =
        
               self->getCurrentViewportId();
        // return type: RObject::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getModelSpaceBlockId", 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 'RBlock::Id'
    RBlock::Id cppResult =
        
               self->getModelSpaceBlockId();
        // return type: RBlock::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


        
    
    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 'void'
    
               self->setCurrentView(a0);
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RTransaction * */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument is pointer
                    RTransaction * a0 = NULL;

                    a0 = 
                        REcmaHelper::scriptValueTo<RTransaction >(
                            context->argument(0)
                        );
                    
                    if (a0==NULL && 
                        !context->argument(0).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 0 is not of type RTransaction *RTransaction *.", context);                    
                    }
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
    // end of arguments

    // call C++ function:
    // return type 'QSharedPointer < RDocumentVariables >'
    QSharedPointer < RDocumentVariables > cppResult =
        
               self->startDocumentVariablesTransaction(a0
        ,
    a1);
        // return type: QSharedPointer < RDocumentVariables >
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    3 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: RTransaction * */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
     && (
            context->argument(2).isVariant() || 
            context->argument(2).isQObject() || 
            context->argument(2).isNull()
        ) /* type: QSharedPointer < RDocumentVariables > */
    
    ){
    // prepare arguments:
    
                    // argument is pointer
                    RTransaction * a0 = NULL;

                    a0 = 
                        REcmaHelper::scriptValueTo<RTransaction >(
                            context->argument(0)
                        );
                    
                    if (a0==NULL && 
                        !context->argument(0).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 0 is not of type RTransaction *RTransaction *.", context);                    
                    }
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
                    // argument is SharedPointer
                    QSharedPointer < RDocumentVariables > 
                    a2;

                    // argument might be a simple pointer:
                     RDocumentVariables * o2 = 
                    qscriptvalue_cast < RDocumentVariables * > (context->argument(2));

                    if (o2!=NULL) {
                        a2 =
                        
                          // never clone RObject based object:
                          QSharedPointer < RDocumentVariables >(o2);
                        
                    }
                    else {
                        // qscriptvalue_cast to QSharedPointer<BaseClass> does not work
                        QSharedPointer < RDocumentVariables >*
                        p2;

                        p2 =
                        qscriptvalue_cast <QSharedPointer < RDocumentVariables >* > (context->argument(2));

                        if (p2==NULL) {
                           return REcmaHelper::throwError("RStorage: Argument 2 is not of type  RDocumentVariables .", context);                    
                        }

                        a2 = *p2;

                           //return REcmaHelper::throwError("RStorage: Argument 2 is not of type  RDocumentVariables .",
                           //    context);                    
                    }

                    //QSharedPointer < RDocumentVariables > 
                    //a2 =
                    //QSharedPointer < RDocumentVariables >(o2->clone());
                
    // end of arguments

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


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

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

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

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


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isNumber()
        ) /* type: RS::Unit */
     && (
            context->argument(1).isVariant() || 
            context->argument(1).isQObject() || 
            context->argument(1).isNull()
        ) /* type: RTransaction * */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    RS::Unit
                    a0 =
                    (RS::Unit)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
                    // argument is pointer
                    RTransaction * a1 = NULL;

                    a1 = 
                        REcmaHelper::scriptValueTo<RTransaction >(
                            context->argument(1)
                        );
                    
                    if (a1==NULL && 
                        !context->argument(1).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 1 is not of type RTransaction *RTransaction *.", context);                    
                    }
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getUnit", 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 'RS::Unit'
    RS::Unit cppResult =
        
               self->getUnit();
        // return type: RS::Unit
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isNumber()
        ) /* type: RS::Measurement */
     && (
            context->argument(1).isVariant() || 
            context->argument(1).isQObject() || 
            context->argument(1).isNull()
        ) /* type: RTransaction * */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    RS::Measurement
                    a0 =
                    (RS::Measurement)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
                    // argument is pointer
                    RTransaction * a1 = NULL;

                    a1 = 
                        REcmaHelper::scriptValueTo<RTransaction >(
                            context->argument(1)
                        );
                    
                    if (a1==NULL && 
                        !context->argument(1).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 1 is not of type RTransaction *RTransaction *.", context);                    
                    }
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getMeasurement", 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 'RS::Measurement'
    RS::Measurement cppResult =
        
               self->getMeasurement();
        // return type: RS::Measurement
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 'void'
    
               self->setDimensionFont(a0);
    } else


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isString()
        ) /* type: QString */
     && (
            context->argument(1).isVariant() || 
            context->argument(1).isQObject() || 
            context->argument(1).isNull()
        ) /* type: RTransaction * */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    QString
                    a0 =
                    (QString)
                    
                    context->argument( 0 ).
                    toString();
                
                    // argument is pointer
                    RTransaction * a1 = NULL;

                    a1 = 
                        REcmaHelper::scriptValueTo<RTransaction >(
                            context->argument(1)
                        );
                    
                    if (a1==NULL && 
                        !context->argument(1).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 1 is not of type RTransaction *RTransaction *.", context);                    
                    }
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getDimensionFont", 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 'QString'
    QString cppResult =
        
               self->getDimensionFont();
        // return type: QString
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isNumber()
        ) /* type: double */
     && (
            context->argument(1).isVariant() || 
            context->argument(1).isQObject() || 
            context->argument(1).isNull()
        ) /* type: RTransaction * */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    double
                    a0 =
                    (double)
                    
                    context->argument( 0 ).
                    toNumber();
                
                    // argument is pointer
                    RTransaction * a1 = NULL;

                    a1 = 
                        REcmaHelper::scriptValueTo<RTransaction >(
                            context->argument(1)
                        );
                    
                    if (a1==NULL && 
                        !context->argument(1).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 1 is not of type RTransaction *RTransaction *.", context);                    
                    }
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getLinetypeScale", 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 'double'
    double cppResult =
        
               self->getLinetypeScale();
        // return type: double
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 'QString'
    QString cppResult =
        
               self->getBlockNameFromLayout(a0);
        // return type: QString
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


        
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isNumber()
        ) /* type: RLayout::Id */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    RLayout::Id
                    a0 =
                    (RLayout::Id)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getBlockNames", 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 'QSet < QString >'
    QSet < QString > cppResult =
        
               self->getBlockNames();
        // return type: QSet < QString >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    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 'QSet < QString >'
    QSet < QString > cppResult =
        
               self->getBlockNames(a0);
        // return type: QSet < QString >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 'RBlock::Id'
    RBlock::Id cppResult =
        
               self->getBlockId(a0);
        // return type: RBlock::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 'RBlock::Id'
    RBlock::Id cppResult =
        
               self->getBlockIdAuto(a0);
        // return type: RBlock::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 =
        
               self->hasBlock(a0);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getViewNames", 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 'QSet < QString >'
    QSet < QString > cppResult =
        
               self->getViewNames();
        // return type: QSet < QString >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 'RView::Id'
    RView::Id cppResult =
        
               self->getViewId(a0);
        // return type: RView::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 =
        
               self->hasView(a0);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getLayerNames", 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 'QSet < QString >'
    QSet < QString > cppResult =
        
               self->getLayerNames();
        // return type: QSet < QString >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    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 'QSet < QString >'
    QSet < QString > cppResult =
        
               self->getLayerNames(a0);
        // return type: QSet < QString >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 'RLayer::Id'
    RLayer::Id cppResult =
        
               self->getLayerId(a0);
        // return type: RLayer::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getLayer0Id", 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 'RLayer::Id'
    RLayer::Id cppResult =
        
               self->getLayer0Id();
        // return type: RLayer::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 =
        
               self->hasLayer(a0);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getLayerStateNames", 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 'QSet < QString >'
    QSet < QString > cppResult =
        
               self->getLayerStateNames();
        // return type: QSet < QString >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    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 'QSet < QString >'
    QSet < QString > cppResult =
        
               self->getLayerStateNames(a0);
        // return type: QSet < QString >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 'RLayer::Id'
    RLayer::Id cppResult =
        
               self->getLayerStateId(a0);
        // return type: RLayer::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("hasLayerStates", 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->hasLayerStates();
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 =
        
               self->hasLayerState(a0);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getLayoutNames", 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 'QSet < QString >'
    QSet < QString > cppResult =
        
               self->getLayoutNames();
        // return type: QSet < QString >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


        
    
    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 'QSet < QString >'
    QSet < QString > cppResult =
        
               self->getLayoutNames(a0);
        // return type: QSet < QString >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 'RLayout::Id'
    RLayout::Id cppResult =
        
               self->getLayoutId(a0);
        // return type: RLayout::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 =
        
               self->hasLayout(a0);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


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

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

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

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


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getLinetypeNames", 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 'QSet < QString >'
    QSet < QString > cppResult =
        
               self->getLinetypeNames();
        // return type: QSet < QString >
                // QSet (convert to QVariantList):
                result = REcmaHelper::setToScriptValue(engine, cppResult);

                
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getLinetypePatterns", 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 'QList < RLinetypePattern >'
    QList < RLinetypePattern > cppResult =
        
               self->getLinetypePatterns();
        // return type: QList < RLinetypePattern >
                // List of ...:
                result = REcmaHelper::listToScriptValue(engine, cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 'RLinetype::Id'
    RLinetype::Id cppResult =
        
               self->getLinetypeId(a0);
        // return type: RLinetype::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 =
        
               self->hasLinetype(a0);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getVariables", 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 'QStringList'
    QStringList cppResult =
        
               self->getVariables();
        // return type: QStringList
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isString()
        ) /* type: QString */
     && (
            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 isStandardType
                    QString
                    a0 =
                    (QString)
                    
                    context->argument( 0 ).
                    toString();
                
                    // argument isCopyable or pointer
                    QVariant
                    a1 =
                    qscriptvalue_cast<
                    QVariant
                        >(
                        context->argument(
                        1
                        )
                    );
                
    // end of arguments

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


        
    
    if( context->argumentCount() ==
    3 && (
            context->argument(0).isString()
        ) /* type: QString */
     && (
            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 isStandardType
                    QString
                    a0 =
                    (QString)
                    
                    context->argument( 0 ).
                    toString();
                
                    // 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 'void'
    
               self->setVariable(a0
        ,
    a1
        ,
    a2);
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 'void'
    
               self->removeVariable(a0);
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 'QVariant'
    QVariant cppResult =
        
               self->getVariable(a0);
        // return type: QVariant
                // QVariant:
                result = REcmaHelper::toScriptValue(engine, cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    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 =
        
               self->hasVariable(a0);
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isNumber()
        ) /* type: RS::KnownVariable */
     && (
            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 isStandardType
                    RS::KnownVariable
                    a0 =
                    (RS::KnownVariable)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
                    // argument isCopyable or pointer
                    QVariant
                    a1 =
                    qscriptvalue_cast<
                    QVariant
                        >(
                        context->argument(
                        1
                        )
                    );
                
    // end of arguments

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


        
    
    if( context->argumentCount() ==
    3 && (
            context->argument(0).isNumber()
        ) /* type: RS::KnownVariable */
     && (
            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).isVariant() || 
            context->argument(2).isQObject() || 
            context->argument(2).isNull()
        ) /* type: RTransaction * */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    RS::KnownVariable
                    a0 =
                    (RS::KnownVariable)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
                    // argument isCopyable or pointer
                    QVariant
                    a1 =
                    qscriptvalue_cast<
                    QVariant
                        >(
                        context->argument(
                        1
                        )
                    );
                
                    // argument is pointer
                    RTransaction * a2 = NULL;

                    a2 = 
                        REcmaHelper::scriptValueTo<RTransaction >(
                            context->argument(2)
                        );
                    
                    if (a2==NULL && 
                        !context->argument(2).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 2 is not of type RTransaction *RTransaction *.", context);                    
                    }
                
    // end of arguments

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


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

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

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

    // call C++ function:
    // return type 'QVariant'
    QVariant cppResult =
        
               self->getKnownVariable(a0);
        // return type: QVariant
                // QVariant:
                result = REcmaHelper::toScriptValue(engine, cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("countSelectedEntities", 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 'int'
    int cppResult =
        
               self->countSelectedEntities();
        // return type: int
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("clearEntitySelection", 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->clearEntitySelection();
    } else


        
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isArray()
        ) /* type: QSet < REntity::Id > * */
    
    ){
    // prepare arguments:
    
                    // argument is pointer
                    QSet < REntity::Id > * a0 = NULL;

                    a0 = 
                        REcmaHelper::scriptValueTo<QSet < REntity::Id > >(
                            context->argument(0)
                        );
                    
                    if (a0==NULL && 
                        !context->argument(0).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 0 is not of type QSet < REntity::Id > *QSet < REntity::Id > *.", context);                    
                    }
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("selectAllEntities", 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->selectAllEntities();
    } else


        
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isArray()
        ) /* type: QSet < REntity::Id > * */
    
    ){
    // prepare arguments:
    
                    // argument is pointer
                    QSet < REntity::Id > * a0 = NULL;

                    a0 = 
                        REcmaHelper::scriptValueTo<QSet < REntity::Id > >(
                            context->argument(0)
                        );
                    
                    if (a0==NULL && 
                        !context->argument(0).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 0 is not of type QSet < REntity::Id > *QSet < REntity::Id > *.", context);                    
                    }
                
    // end of arguments

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


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

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

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

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


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isNumber()
        ) /* type: REntity::Id */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    REntity::Id
                    a0 =
                    (REntity::Id)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
    // end of arguments

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


        
    
    if( context->argumentCount() ==
    3 && (
            context->argument(0).isNumber()
        ) /* type: REntity::Id */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
     && (
            context->argument(2).isArray()
        ) /* type: QSet < REntity::Id > * */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    REntity::Id
                    a0 =
                    (REntity::Id)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
                    // argument is pointer
                    QSet < REntity::Id > * a2 = NULL;

                    a2 = 
                        REcmaHelper::scriptValueTo<QSet < REntity::Id > >(
                            context->argument(2)
                        );
                    
                    if (a2==NULL && 
                        !context->argument(2).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 2 is not of type QSet < REntity::Id > *QSet < REntity::Id > *.", context);                    
                    }
                
    // end of arguments

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


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isArray()
        ) /* type: QSet < REntity::Id > */
    
    ){
    // prepare arguments:
    
                    // argument isArray
                    QSet < REntity::Id >
                    a0;
                    REcmaHelper::fromScriptValue(
                        engine,
                        context->argument(0),
                        a0
                    );
                
    // end of arguments

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


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isArray()
        ) /* type: QSet < REntity::Id > */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isArray
                    QSet < REntity::Id >
                    a0;
                    REcmaHelper::fromScriptValue(
                        engine,
                        context->argument(0),
                        a0
                    );
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
    // end of arguments

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


        
    
    if( context->argumentCount() ==
    3 && (
            context->argument(0).isArray()
        ) /* type: QSet < REntity::Id > */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
     && (
            context->argument(2).isArray()
        ) /* type: QSet < REntity::Id > * */
    
    ){
    // prepare arguments:
    
                    // argument isArray
                    QSet < REntity::Id >
                    a0;
                    REcmaHelper::fromScriptValue(
                        engine,
                        context->argument(0),
                        a0
                    );
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
                    // argument is pointer
                    QSet < REntity::Id > * a2 = NULL;

                    a2 = 
                        REcmaHelper::scriptValueTo<QSet < REntity::Id > >(
                            context->argument(2)
                        );
                    
                    if (a2==NULL && 
                        !context->argument(2).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 2 is not of type QSet < REntity::Id > *QSet < REntity::Id > *.", context);                    
                    }
                
    // end of arguments

    // call C++ function:
    // return type 'int'
    int cppResult =
        
               self->selectEntities(a0
        ,
    a1
        ,
    a2);
        // return type: int
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isNumber()
        ) /* type: REntity::Id */
     && (
            context->argument(1).isArray()
        ) /* type: QSet < REntity::Id > * */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    REntity::Id
                    a0 =
                    (REntity::Id)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
                    // argument is pointer
                    QSet < REntity::Id > * a1 = NULL;

                    a1 = 
                        REcmaHelper::scriptValueTo<QSet < REntity::Id > >(
                            context->argument(1)
                        );
                    
                    if (a1==NULL && 
                        !context->argument(1).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 1 is not of type QSet < REntity::Id > *QSet < REntity::Id > *.", context);                    
                    }
                
    // end of arguments

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


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isArray()
        ) /* type: QSet < REntity::Id > */
    
    ){
    // prepare arguments:
    
                    // argument isArray
                    QSet < REntity::Id >
                    a0;
                    REcmaHelper::fromScriptValue(
                        engine,
                        context->argument(0),
                        a0
                    );
                
    // end of arguments

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


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isArray()
        ) /* type: QSet < REntity::Id > */
     && (
            context->argument(1).isArray()
        ) /* type: QSet < REntity::Id > * */
    
    ){
    // prepare arguments:
    
                    // argument isArray
                    QSet < REntity::Id >
                    a0;
                    REcmaHelper::fromScriptValue(
                        engine,
                        context->argument(0),
                        a0
                    );
                
                    // argument is pointer
                    QSet < REntity::Id > * a1 = NULL;

                    a1 = 
                        REcmaHelper::scriptValueTo<QSet < REntity::Id > >(
                            context->argument(1)
                        );
                    
                    if (a1==NULL && 
                        !context->argument(1).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 1 is not of type QSet < REntity::Id > *QSet < REntity::Id > *.", context);                    
                    }
                
    // end of arguments

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

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

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


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

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


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isVariant() || 
            context->argument(0).isQObject() || 
            context->argument(0).isNull()
        ) /* type: REntity */
     && (
            context->argument(1).isNumber()
        ) /* type: RBlock::Id */
    
    ){
    // prepare arguments:
    
                    // argument is reference
                    REntity*
                    ap0 =
                    qscriptvalue_cast<
                    REntity*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if( ap0 == NULL ){
                           return REcmaHelper::throwError("RStorage: Argument 0 is not of type REntity*.",
                               context);                    
                    }
                    REntity& a0 = *ap0;
                
                    // argument isStandardType
                    RBlock::Id
                    a1 =
                    (RBlock::Id)
                    (int)
                    context->argument( 1 ).
                    toNumber();
                
    // end of arguments

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isNumber()
        ) /* type: RObject::Id */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    RObject::Id
                    a0 =
                    (RObject::Id)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("hasSelection", 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->hasSelection();
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getBoundingBox", 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 'RBox'
    RBox cppResult =
        
               self->getBoundingBox();
        // return type: RBox
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    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 'RBox'
    RBox cppResult =
        
               self->getBoundingBox(a0);
        // return type: RBox
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


        
    
    if( context->argumentCount() ==
    2 && (
            context->argument(0).isBool()
        ) /* type: bool */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    bool
                    a0 =
                    (bool)
                    
                    context->argument( 0 ).
                    toBool();
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getSelectionBox", 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 'RBox'
    RBox cppResult =
        
               self->getSelectionBox();
        // return type: RBox
                // not standard type nor reference
                result = qScriptValueFromValue(engine, cppResult);
            
    } else


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isArray()
        ) /* type: QSet < REntity::Id > */
    
    ){
    // prepare arguments:
    
                    // argument isArray
                    QSet < REntity::Id >
                    a0;
                    REcmaHelper::fromScriptValue(
                        engine,
                        context->argument(0),
                        a0
                    );
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("removeObject", 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: QSharedPointer < RObject > */
    
    ){
    // prepare arguments:
    
                    // argument is SharedPointer
                    QSharedPointer < RObject > 
                    a0;

                    // argument might be a simple pointer:
                     RObject * o0 = 
                    qscriptvalue_cast < RObject * > (context->argument(0));

                    if (o0!=NULL) {
                        a0 =
                        
                          // never clone RObject based object:
                          QSharedPointer < RObject >(o0);
                        
                    }
                    else {
                        // qscriptvalue_cast to QSharedPointer<BaseClass> does not work
                        QSharedPointer < RObject >*
                        p0;

                        p0 =
                        qscriptvalue_cast <QSharedPointer < RObject >* > (context->argument(0));

                        if (p0==NULL) {
                           return REcmaHelper::throwError("RStorage: Argument 0 is not of type  RObject .", context);                    
                        }

                        a0 = *p0;

                           //return REcmaHelper::throwError("RStorage: Argument 0 is not of type  RObject .",
                           //    context);                    
                    }

                    //QSharedPointer < RObject > 
                    //a0 =
                    //QSharedPointer < RObject >(o0->clone());
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("saveObject", 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: QSharedPointer < RObject > */
    
    ){
    // prepare arguments:
    
                    // argument is SharedPointer
                    QSharedPointer < RObject > 
                    a0;

                    // argument might be a simple pointer:
                     RObject * o0 = 
                    qscriptvalue_cast < RObject * > (context->argument(0));

                    if (o0!=NULL) {
                        a0 =
                        
                          // never clone RObject based object:
                          QSharedPointer < RObject >(o0);
                        
                    }
                    else {
                        // qscriptvalue_cast to QSharedPointer<BaseClass> does not work
                        QSharedPointer < RObject >*
                        p0;

                        p0 =
                        qscriptvalue_cast <QSharedPointer < RObject >* > (context->argument(0));

                        if (p0==NULL) {
                           return REcmaHelper::throwError("RStorage: Argument 0 is not of type  RObject .", context);                    
                        }

                        a0 = *p0;

                           //return REcmaHelper::throwError("RStorage: Argument 0 is not of type  RObject .",
                           //    context);                    
                    }

                    //QSharedPointer < RObject > 
                    //a0 =
                    //QSharedPointer < RObject >(o0->clone());
                
    // end of arguments

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        
               self->saveObject(a0);
        // 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: QSharedPointer < RObject > */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument is SharedPointer
                    QSharedPointer < RObject > 
                    a0;

                    // argument might be a simple pointer:
                     RObject * o0 = 
                    qscriptvalue_cast < RObject * > (context->argument(0));

                    if (o0!=NULL) {
                        a0 =
                        
                          // never clone RObject based object:
                          QSharedPointer < RObject >(o0);
                        
                    }
                    else {
                        // qscriptvalue_cast to QSharedPointer<BaseClass> does not work
                        QSharedPointer < RObject >*
                        p0;

                        p0 =
                        qscriptvalue_cast <QSharedPointer < RObject >* > (context->argument(0));

                        if (p0==NULL) {
                           return REcmaHelper::throwError("RStorage: Argument 0 is not of type  RObject .", context);                    
                        }

                        a0 = *p0;

                           //return REcmaHelper::throwError("RStorage: Argument 0 is not of type  RObject .",
                           //    context);                    
                    }

                    //QSharedPointer < RObject > 
                    //a0 =
                    //QSharedPointer < RObject >(o0->clone());
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
    // end of arguments

    // call C++ function:
    // return type 'bool'
    bool cppResult =
        
               self->saveObject(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: QSharedPointer < RObject > */
     && (
            context->argument(1).isBool()
        ) /* type: bool */
     && (
            context->argument(2).isBool()
        ) /* type: bool */
    
    ){
    // prepare arguments:
    
                    // argument is SharedPointer
                    QSharedPointer < RObject > 
                    a0;

                    // argument might be a simple pointer:
                     RObject * o0 = 
                    qscriptvalue_cast < RObject * > (context->argument(0));

                    if (o0!=NULL) {
                        a0 =
                        
                          // never clone RObject based object:
                          QSharedPointer < RObject >(o0);
                        
                    }
                    else {
                        // qscriptvalue_cast to QSharedPointer<BaseClass> does not work
                        QSharedPointer < RObject >*
                        p0;

                        p0 =
                        qscriptvalue_cast <QSharedPointer < RObject >* > (context->argument(0));

                        if (p0==NULL) {
                           return REcmaHelper::throwError("RStorage: Argument 0 is not of type  RObject .", context);                    
                        }

                        a0 = *p0;

                           //return REcmaHelper::throwError("RStorage: Argument 0 is not of type  RObject .",
                           //    context);                    
                    }

                    //QSharedPointer < RObject > 
                    //a0 =
                    //QSharedPointer < RObject >(o0->clone());
                
                    // argument isStandardType
                    bool
                    a1 =
                    (bool)
                    
                    context->argument( 1 ).
                    toBool();
                
                    // argument isStandardType
                    bool
                    a2 =
                    (bool)
                    
                    context->argument( 2 ).
                    toBool();
                
    // end of arguments

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


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getLastTransactionId", 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 'int'
    int cppResult =
        
               self->getLastTransactionId();
        // return type: int
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("startTransactionGroup", 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->startTransactionGroup();
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getTransactionGroup", 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 'int'
    int cppResult =
        
               self->getTransactionGroup();
        // return type: int
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("saveTransaction", 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: RTransaction */
    
    ){
    // prepare arguments:
    
                    // argument isCopyable and has default constructor and isSimpleClass 
                    RTransaction*
                    ap0 =
                    qscriptvalue_cast<
                    RTransaction*
                        >(
                        context->argument(
                        0
                        )
                    );
                    if (ap0 == NULL) {
                           return REcmaHelper::throwError("RStorage: Argument 0 is not of type RTransaction.",
                               context);                    
                    }
                    RTransaction 
                    a0 = 
                    *ap0;
                
    // end of arguments

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


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("resetTransactionStack", 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->resetTransactionStack();
    } else


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

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

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

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


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

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

                //Q_ASSERT(self!=NULL);
                if (self==NULL) {
                    return REcmaHelper::throwError("self is NULL", context);
                }
                
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isArray()
        ) /* type: QSet < RObject::Id > */
    
    ){
    // prepare arguments:
    
                    // argument isArray
                    QSet < RObject::Id >
                    a0;
                    REcmaHelper::fromScriptValue(
                        engine,
                        context->argument(0),
                        a0
                    );
                
    // end of arguments

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


        
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isNumber()
        ) /* type: RObject::Id */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    RObject::Id
                    a0 =
                    (RObject::Id)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getMaxTransactionId", 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 'int'
    int cppResult =
        
               self->getMaxTransactionId();
        // return type: int
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getMaxLineweight", 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 'RLineweight::Lineweight'
    RLineweight::Lineweight cppResult =
        
               self->getMaxLineweight();
        // return type: RLineweight::Lineweight
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getNewObjectId", 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 'RObject::Id'
    RObject::Id cppResult =
        
               self->getNewObjectId();
        // return type: RObject::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getMaxObjectId", 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 'RObject::Id'
    RObject::Id cppResult =
        
               self->getMaxObjectId();
        // return type: RObject::Id
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getNewObjectHandle", 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 'RObject::Handle'
    RObject::Handle cppResult =
        
               self->getNewObjectHandle();
        // return type: RObject::Handle
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getMaxObjectHandle", 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 'RObject::Handle'
    RObject::Handle cppResult =
        
               self->getMaxObjectHandle();
        // return type: RObject::Handle
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getMaxDrawOrder", 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 'int'
    int cppResult =
        
               self->getMaxDrawOrder();
        // return type: int
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getMinDrawOrder", 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 'int'
    int cppResult =
        
               self->getMinDrawOrder();
        // return type: int
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

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

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

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


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

            QScriptValue result = engine->undefinedValue();
            
    
    if( context->argumentCount() ==
    1 && (
            context->argument(0).isNumber()
        ) /* type: RS::KnownVariable */
    
    ){
    // prepare arguments:
    
                    // argument isStandardType
                    RS::KnownVariable
                    a0 =
                    (RS::KnownVariable)
                    (int)
                    context->argument( 0 ).
                    toNumber();
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("setModified", 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->setModified(a0);
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("isModified", 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->isModified();
        // return type: bool
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("getLastModified", 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 'QString'
    QString cppResult =
        
               self->getLastModified();
        // return type: QString
                // standard Type
                result = QScriptValue(cppResult);
            
    } else


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("addModifiedListener", 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: RModifiedListener * */
    
    ){
    // prepare arguments:
    
                    // argument is pointer
                    RModifiedListener * a0 = NULL;

                    a0 = 
                        REcmaHelper::scriptValueTo<RModifiedListener >(
                            context->argument(0)
                        );
                    
                    if (a0==NULL && 
                        !context->argument(0).isNull()) {
                        return REcmaHelper::throwError("RStorage: Argument 0 is not of type RModifiedListener *RModifiedListener *.", context);                    
                    }
                
    // end of arguments

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


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

            QScriptValue result = engine->undefinedValue();
            
                    // public function: can be called from ECMA wrapper of ECMA shell:
                    RStorage* self = 
                        getSelf("update", 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->update();
    } else


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

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

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

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

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

            return self;
            


        }
        