summaryrefslogtreecommitdiffstats
path: root/src/declarative/qml/qmlcontext.cpp
blob: 40e33c2ed6cb23a93e304674c8fba9ff78f3f80b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Qt Software Information (qt-info@nokia.com)
**
** This file is part of the QtDeclarative module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the either Technology Preview License Agreement or the
** Beta Release License Agreement.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain
** additional rights. These rights are described in the Nokia Qt LGPL
** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
** package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at qt-sales@nokia.com.
** $QT_END_LICENSE$
**
****************************************************************************/

#include <qmlcontext.h>
#include <private/qmlcontext_p.h>
#include <private/qmlengine_p.h>
#include <private/qmlcompiledcomponent_p.h>
#include <qmlengine.h>
#include <qscriptengine.h>

#include <qdebug.h>

// 6-bits
#define MAXIMUM_DEFAULT_OBJECTS 63

QT_BEGIN_NAMESPACE

QmlContextPrivate::QmlContextPrivate()
    : parent(0), engine(0), highPriorityCount(0), component(0)
{
}

void QmlContextPrivate::dump()
{
    dump(0);
}

void QmlContextPrivate::dump(int depth)
{
    QByteArray ba(depth * 4, ' ');
    qWarning() << ba << properties.keys();
    qWarning() << ba << variantProperties.keys();
    if(parent)
        parent->d_func()->dump(depth + 1);
}

void QmlContextPrivate::destroyed(QObject *obj)
{
    defaultObjects.removeAll(obj);
    for(QHash<QString, QObject *>::Iterator iter = properties.begin();
            iter != properties.end(); ) {
        if(*iter == obj)
            iter = properties.erase(iter);
        else
            ++iter;
    }
}

void QmlContextPrivate::init()
{
    Q_Q(QmlContext);
    //set scope chain
    QScriptEngine *scriptEngine = engine->scriptEngine();
    QScriptValue scopeObj =
        scriptEngine->newObject(engine->d_func()->contextClass, scriptEngine->newVariant(QVariant::fromValue((QObject*)q)));
    if (!parent)
        scopeChain.append(scriptEngine->globalObject());
    else
        scopeChain = parent->d_func()->scopeChain;
    scopeChain.prepend(scopeObj);

    contextData.context = q;
}

void QmlContextPrivate::addDefaultObject(QObject *object, Priority priority)
{
    if(defaultObjects.count() >= (MAXIMUM_DEFAULT_OBJECTS - 1)) {
        qWarning("QmlContext: Cannot have more than %d default objects on "
                 "one bind context.", MAXIMUM_DEFAULT_OBJECTS - 1);
        return;
    }

    if(priority == HighPriority) {
        defaultObjects.insert(highPriorityCount++, object);
    } else {
        defaultObjects.append(object);
    }
    QObject::connect(object, SIGNAL(destroyed(QObject*)),
                     q_ptr, SLOT(objectDestroyed(QObject*)));
}


/*!
    \class QmlContext
    \brief The QmlContext class defines a context within a QML engine.
    \mainclass

    Contexts allow data to be exposed to the QML components instantiated by the
    QML engine.

    Each QmlContext contains a set of properties, distinct from
    its QObject properties, that allow data to be
    explicitly bound to a context by name.  The context properties are defined or
    updated by calling QmlContext::setContextProperty().  The following example shows
    a Qt model being bound to a context and then accessed from a QML file.

    \code
    QmlEngine engine;
    QmlContext context(engine.rootContext());
    context.setContextProperty("myModel", modelData);

    QmlComponent component("<ListView model=\"{myModel}\" />");
    component.create(&context);
    \endcode

    To simplify binding and maintaining larger data sets, QObject's can be
    added to a QmlContext.  These objects are known as the context's default
    objects.  In this case all the properties of the QObject are
    made available by name in the context, as though they were all individually
    added by calling QmlContext::setContextProperty().  Changes to the property's
    values are detected through the property's notify signal.  This method is
    also slightly more faster than manually adding property values.

    The following example has the same effect as the one above, but it is
    achieved using a default object.

    \code
    class MyDataSet : ... {
        ...
        Q_PROPERTY(QAbstractItemModel *myModel READ model NOTIFY modelChanged);
        ...
    };

    MyDataSet myDataSet;
    QmlEngine engine;
    QmlContext context(engine.rootContext());
    context.addDefaultObject(&myDataSet);

    QmlComponent component("<ListView model=\"{myModel}\" />");
    component.create(&context);
    \endcode

    Each context may have up to 32 default objects, and objects added first take
    precedence over those added later.  All properties added explicitly by
    QmlContext::setContextProperty() take precedence over default object properties.

    Contexts are hierarchal, with the \l {QmlEngine::rootContext()}{root context}
    being created by the QmlEngine.  A component instantiated in a given context
    has access to that context's data, as well as the data defined by its
    ancestor contexts.  Data values (including those added implicitly by the
    default objects) in a context override those in ancestor contexts.  Data
    that should be available to all components instantiated by the QmlEngine
    should be added to the \l {QmlEngine::rootContext()}{root context}.

    In the following example,

    \code
    QmlEngine engine;
    QmlContext context1(engine.rootContext());
    QmlContext context2(&context1);
    QmlContext context3(&context2);

    context1.setContextProperty("a", 12);
    context2.setContextProperty("b", 13);
    context3.setContextProperty("a", 14);
    context3.setContextProperty("c", 14);
    \endcode

    a QML component instantiated in context1 would have access to the "a" data,
    a QML component instantiated in context2 would have access to the "a" and
    "b" data, and a QML component instantiated in context3 would have access to
    the "a", "b" and "c" data - although its "a" data would return 14, unlike
    that in context1 or context2.
*/

/*! \internal */
QmlContext::QmlContext(QmlEngine *e)
: QObject(*(new QmlContextPrivate))
{
    Q_D(QmlContext);
    d->engine = e;
    d->init();
}

/*!
    Create a new QmlContext with the given \a parentContext, and the
    QObject \a parent.
*/
QmlContext::QmlContext(QmlContext *parentContext, QObject *parent)
: QObject(*(new QmlContextPrivate), parent)
{
    Q_D(QmlContext);
    d->parent = parentContext;
    d->engine = parentContext->engine();
    d->init();
}

/*!
    Destroys the QmlContext.

    Any expressions, or sub-contexts dependent on this context will be
    invalidated, but not destroyed (unless they are parented to the QmlContext
    object).
 */
QmlContext::~QmlContext()
{
    Q_D(QmlContext);
    if(d->component) d->component->release();
}


/*!
    Return the context's QmlEngine, or 0 if the context has no QmlEngine or the
    QmlEngine was destroyed.
*/
QmlEngine *QmlContext::engine() const
{
    Q_D(const QmlContext);
    return d->engine;
}

/*!
    Return the context's parent QmlContext, or 0 if this context has no
    parent or if the parent has been destroyed.
*/
QmlContext *QmlContext::parentContext() const
{
    Q_D(const QmlContext);
    return d->parent;
}

/*!
    Add a default \a object to this context.  The object will be added after
    any existing default objects.
*/
void QmlContext::addDefaultObject(QObject *defaultObject)
{
    Q_D(QmlContext);
    d->addDefaultObject(defaultObject, QmlContextPrivate::NormalPriority);
}

/*!
    Set a the \a value of the \a name property on this context.
*/
void QmlContext::setContextProperty(const QString &name, const QVariant &value)
{
    Q_D(QmlContext);
    d->variantProperties.insert(name, value);
}

/*!
    Set a the \a value of the \a name property on this context.

    QmlContext does \b not take ownership of \a value.
*/
void QmlContext::setContextProperty(const QString &name, QObject *value)
{
    Q_D(QmlContext);
    d->properties.insert(name, value);
    QObject::connect(value, SIGNAL(destroyed(QObject*)), this, SLOT(objectDestroyed(QObject*)));
}

/*!
    Activate this bind context.

    \sa QmlEngine::activeContext() QmlContext::activeContext()
*/
void QmlContext::activate()
{
    QmlEnginePrivate *ep = engine()->d_func();
    ep->activeContexts.push(this);
    ep->setCurrentBindContext(this);
    ep->contextActivated(this);
}

/*!
    Deactivate this bind context.  The previously active bind context will
    become active, or, if there was no previously active bind context, no
    context will be active.

    \sa QmlEngine::activeContext() QmlContext::activeContext()
*/
void QmlContext::deactivate()
{
    QmlEnginePrivate *ep = engine()->d_func();
    Q_ASSERT(ep->activeContexts.top() == this);
    ep->activeContexts.pop();
    if(ep->activeContexts.isEmpty())
        ep->setCurrentBindContext(0);
    else
        ep->setCurrentBindContext(ep->activeContexts.top());
    ep->contextDeactivated(this);
}

/*!
    Returns the currently active context, or 0 if no context is active.

    This method is thread-safe.  The active context is maintained individually
    for each thread.  This method is equivalent to
    \code
    QmlEngine::activeEngine()->activeContext()
    \endcode
*/
QmlContext *QmlContext::activeContext()
{
    QmlEngine *engine = QmlEngine::activeEngine();
    if(engine)
        return engine->activeContext();
    else
        return 0;
}

/*!
    Resolves the URL \a src relative to the URL of the
    containing component.

    If \a src is absolute, it is simply returned.

    If there is no containing component, an empty URL is returned.

    \sa componentUrl
*/
QUrl QmlContext::resolvedUrl(const QUrl &src)
{
    QmlContext *ctxt = this;
    if(src.isRelative()) {
        if(ctxt) {
            while(ctxt) {
                if(ctxt->d_func()->component)
                    break;
                else
                    ctxt = ctxt->parentContext();
            }

            if(ctxt)
                return ctxt->d_func()->component->url.resolved(src);
        }
        return QUrl();
    } else {
        return src;
    }
}

/*!
    Resolves the component URI \a src relative to the URL of the
    containing component, and according to the
    \link QmlEngine::nameSpacePaths() namespace paths\endlink of the
    context's engine, returning the resolved URL.

    \sa componentUrl
*/
QUrl QmlContext::resolvedUri(const QUrl &src)
{
    QmlContext *ctxt = this;
    if(src.isRelative()) {
        if(ctxt) {
            while(ctxt) {
                if(ctxt->d_func()->component)
                    break;
                else
                    ctxt = ctxt->parentContext();
            }

            if(ctxt)
                return ctxt->d_func()->engine->componentUrl(src, ctxt->d_func()->component->url);
        }
        return QUrl();
    } else {
        return ctxt->d_func()->engine->componentUrl(src, QUrl());
    }
}

void QmlContext::objectDestroyed(QObject *object)
{
    Q_D(QmlContext);
    d->destroyed(object);
}

QT_END_NAMESPACE