1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtDeclarative module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qdeclarativeinclude_p.h"

    43 

    44 #include <QtScript/qscriptengine.h>

    45 #include <QtNetwork/qnetworkrequest.h>

    46 #include <QtNetwork/qnetworkreply.h>

    47 #include <QtCore/qfile.h>

    48 

    49 #include <private/qdeclarativeengine_p.h>

    50 #include <private/qdeclarativeglobalscriptclass_p.h>

    51 

    52 QT_BEGIN_NAMESPACE

    53 

    54 QDeclarativeInclude::QDeclarativeInclude(const QUrl &url, 

    55                                                        QDeclarativeEngine *engine, 

    56                                                        QScriptContext *ctxt)

    57 : QObject(engine), m_engine(engine), m_network(0), m_reply(0), m_url(url), m_redirectCount(0)

    58 {

    59     QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);

    60     m_context = ep->contextClass->contextFromValue(QScriptDeclarativeClass::scopeChainValue(ctxt, -3));

    61 

    62     m_scope[0] = QScriptDeclarativeClass::scopeChainValue(ctxt, -4);

    63     m_scope[1] = QScriptDeclarativeClass::scopeChainValue(ctxt, -5);

    64 

    65     m_scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);

    66     m_network = QDeclarativeScriptEngine::get(m_scriptEngine)->networkAccessManager();

    67 

    68     m_result = resultValue(m_scriptEngine);

    69 

    70     QNetworkRequest request;

    71     request.setUrl(url);

    72 

    73     m_reply = m_network->get(request);

    74     QObject::connect(m_reply, SIGNAL(finished()), this, SLOT(finished()));

    75 }

    76 

    77 QDeclarativeInclude::~QDeclarativeInclude()

    78 {

    79     delete m_reply;

    80 }

    81 

    82 QScriptValue QDeclarativeInclude::resultValue(QScriptEngine *engine, Status status)

    83 {

    84     QScriptValue result = engine->newObject();

    85     result.setProperty(QLatin1String("OK"), QScriptValue(engine, Ok));

    86     result.setProperty(QLatin1String("LOADING"), QScriptValue(engine, Loading));

    87     result.setProperty(QLatin1String("NETWORK_ERROR"), QScriptValue(engine, NetworkError));

    88     result.setProperty(QLatin1String("EXCEPTION"), QScriptValue(engine, Exception));

    89 

    90     result.setProperty(QLatin1String("status"), QScriptValue(engine, status));

    91     return result;

    92 }

    93 

    94 QScriptValue QDeclarativeInclude::result() const

    95 {

    96     return m_result;

    97 }

    98 

    99 void QDeclarativeInclude::setCallback(const QScriptValue &c)

   100 {

   101     m_callback = c;

   102 }

   103 

   104 QScriptValue QDeclarativeInclude::callback() const

   105 {

   106     return m_callback;

   107 }

   108 

   109 #define INCLUDE_MAXIMUM_REDIRECT_RECURSION 15

   110 void QDeclarativeInclude::finished()

   111 {

   112     m_redirectCount++;

   113 

   114     if (m_redirectCount < INCLUDE_MAXIMUM_REDIRECT_RECURSION) {

   115         QVariant redirect = m_reply->attribute(QNetworkRequest::RedirectionTargetAttribute);

   116         if (redirect.isValid()) {

   117             m_url = m_url.resolved(redirect.toUrl());

   118             delete m_reply; 

   119             

   120             QNetworkRequest request;

   121             request.setUrl(m_url);

   122 

   123             m_reply = m_network->get(request);

   124             QObject::connect(m_reply, SIGNAL(finished()), this, SLOT(finished()));

   125             return;

   126         }

   127     }

   128 

   129     if (m_reply->error() == QNetworkReply::NoError) {

   130         QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(m_engine);

   131 

   132         QByteArray data = m_reply->readAll();

   133 

   134         QString code = QString::fromUtf8(data);

   135 

   136         QString urlString = m_url.toString();

   137         QScriptContext *scriptContext = QScriptDeclarativeClass::pushCleanContext(m_scriptEngine);

   138         scriptContext->pushScope(ep->contextClass->newUrlContext(m_context, 0, urlString));

   139         scriptContext->pushScope(m_scope[0]);

   140 

   141         scriptContext->pushScope(m_scope[1]);

   142         scriptContext->setActivationObject(m_scope[1]);

   143         QDeclarativeScriptParser::extractPragmas(code);

   144 

   145         m_scriptEngine->evaluate(code, urlString, 1);

   146 

   147         m_scriptEngine->popContext();

   148 

   149         if (m_scriptEngine->hasUncaughtException()) {

   150             m_result.setProperty(QLatin1String("status"), QScriptValue(m_scriptEngine, Exception));

   151             m_result.setProperty(QLatin1String("exception"), m_scriptEngine->uncaughtException());

   152             m_scriptEngine->clearExceptions();

   153         } else {

   154             m_result.setProperty(QLatin1String("status"), QScriptValue(m_scriptEngine, Ok));

   155         }

   156     } else {

   157         m_result.setProperty(QLatin1String("status"), QScriptValue(m_scriptEngine, NetworkError));

   158     }

   159 

   160     callback(m_scriptEngine, m_callback, m_result);

   161 

   162     disconnect();

   163     deleteLater();

   164 }

   165 

   166 void QDeclarativeInclude::callback(QScriptEngine *engine, QScriptValue &callback, QScriptValue &status)

   167 {

   168     if (callback.isValid()) {

   169         QScriptValue args = engine->newArray(1);

   170         args.setProperty(0, status);

   171         callback.call(QScriptValue(), args);

   172     }

   173 }

   174 

   175 QScriptValue QDeclarativeInclude::include(QScriptContext *ctxt, QScriptEngine *engine)

   176 {

   177     if (ctxt->argumentCount() == 0)

   178         return engine->undefinedValue();

   179 

   180     QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);

   181 

   182     QUrl contextUrl = ep->contextClass->urlFromValue(QScriptDeclarativeClass::scopeChainValue(ctxt, -3));

   183     if (contextUrl.isEmpty()) 

   184         return ctxt->throwError(QLatin1String("Qt.include(): Can only be called from JavaScript files"));

   185 

   186     QString urlString = ctxt->argument(0).toString();

   187     QUrl url(ctxt->argument(0).toString());

   188     if (url.isRelative()) {

   189         url = QUrl(contextUrl).resolved(url);

   190         urlString = url.toString();

   191     }

   192 

   193     QString localFile = QDeclarativeEnginePrivate::urlToLocalFileOrQrc(url);

   194 

   195     QScriptValue func = ctxt->argument(1);

   196     if (!func.isFunction())

   197         func = QScriptValue();

   198 

   199     QScriptValue result;

   200     if (localFile.isEmpty()) {

   201         QDeclarativeInclude *i = 

   202             new QDeclarativeInclude(url, QDeclarativeEnginePrivate::getEngine(engine), ctxt);

   203 

   204         if (func.isValid())

   205             i->setCallback(func);

   206 

   207         result = i->result();

   208     } else {

   209 

   210         QFile f(localFile);

   211         if (f.open(QIODevice::ReadOnly)) {

   212             QByteArray data = f.readAll();

   213             QString code = QString::fromUtf8(data);

   214 

   215             QDeclarativeContextData *context = 

   216                 ep->contextClass->contextFromValue(QScriptDeclarativeClass::scopeChainValue(ctxt, -3));

   217 

   218             QScriptContext *scriptContext = QScriptDeclarativeClass::pushCleanContext(engine);

   219             scriptContext->pushScope(ep->contextClass->newUrlContext(context, 0, urlString));

   220             scriptContext->pushScope(ep->globalClass->globalObject());

   221             QScriptValue scope = QScriptDeclarativeClass::scopeChainValue(ctxt, -5);

   222             scriptContext->pushScope(scope);

   223             scriptContext->setActivationObject(scope);

   224             QDeclarativeScriptParser::extractPragmas(code);

   225 

   226             engine->evaluate(code, urlString, 1);

   227 

   228             engine->popContext();

   229 

   230             if (engine->hasUncaughtException()) {

   231                 result = resultValue(engine, Exception);

   232                 result.setProperty(QLatin1String("exception"), engine->uncaughtException());

   233                 engine->clearExceptions();

   234             } else {

   235                 result = resultValue(engine, Ok);

   236             }

   237             callback(engine, func, result);

   238         } else {

   239             result = resultValue(engine, NetworkError);

   240             callback(engine, func, result);

   241         }

   242     }

   243 

   244     return result;

   245 }

   246 

   247 QScriptValue QDeclarativeInclude::worker_include(QScriptContext *ctxt, QScriptEngine *engine)

   248 {

   249     if (ctxt->argumentCount() == 0)

   250         return engine->undefinedValue();

   251 

   252     QString urlString = ctxt->argument(0).toString();

   253     QUrl url(ctxt->argument(0).toString());

   254     if (url.isRelative()) {

   255         QString contextUrl = QScriptDeclarativeClass::scopeChainValue(ctxt, -3).data().toString();

   256         Q_ASSERT(!contextUrl.isEmpty());

   257 

   258         url = QUrl(contextUrl).resolved(url);

   259         urlString = url.toString();

   260     }

   261 

   262     QString localFile = QDeclarativeEnginePrivate::urlToLocalFileOrQrc(url);

   263 

   264     QScriptValue func = ctxt->argument(1);

   265     if (!func.isFunction())

   266         func = QScriptValue();

   267 

   268     QScriptValue result;

   269     if (!localFile.isEmpty()) {

   270 

   271         QFile f(localFile);

   272         if (f.open(QIODevice::ReadOnly)) {

   273             QByteArray data = f.readAll();

   274             QString code = QString::fromUtf8(data);

   275 

   276             QScriptContext *scriptContext = QScriptDeclarativeClass::pushCleanContext(engine);

   277             QScriptValue urlContext = engine->newObject();

   278             urlContext.setData(QScriptValue(engine, urlString));

   279             scriptContext->pushScope(urlContext);

   280 

   281             QScriptValue scope = QScriptDeclarativeClass::scopeChainValue(ctxt, -4);

   282             scriptContext->pushScope(scope);

   283             scriptContext->setActivationObject(scope);

   284             QDeclarativeScriptParser::extractPragmas(code);

   285 

   286             engine->evaluate(code, urlString, 1);

   287 

   288             engine->popContext();

   289 

   290             if (engine->hasUncaughtException()) {

   291                 result = resultValue(engine, Exception);

   292                 result.setProperty(QLatin1String("exception"), engine->uncaughtException());

   293                 engine->clearExceptions();

   294             } else {

   295                 result = resultValue(engine, Ok);

   296             }

   297             callback(engine, func, result);

   298         } else {

   299             result = resultValue(engine, NetworkError);

   300             callback(engine, func, result);

   301         }

   302     }

   303 

   304     return result;

   305 }

   306 

   307 QT_END_NAMESPACE